resize2fs.c revision 5e27a274d320b44c631a37d4b04a84aa3ca5428c
1/* 2 * resize2fs.c --- ext2 main routine 3 * 4 * Copyright (C) 1997, 1998 by Theodore Ts'o and 5 * PowerQuest, Inc. 6 * 7 * Copyright (C) 1999, 2000 by Theosore Ts'o 8 * 9 * %Begin-Header% 10 * This file may be redistributed under the terms of the GNU Public 11 * License. 12 * %End-Header% 13 */ 14 15/* 16 * Resizing a filesystem consists of the following phases: 17 * 18 * 1. Adjust superblock and write out new parts of the inode 19 * table 20 * 2. Determine blocks which need to be relocated, and copy the 21 * contents of blocks from their old locations to the new ones. 22 * 3. Scan the inode table, doing the following: 23 * a. If blocks have been moved, update the block 24 * pointers in the inodes and indirect blocks to 25 * point at the new block locations. 26 * b. If parts of the inode table need to be evacuated, 27 * copy inodes from their old locations to their 28 * new ones. 29 * c. If (b) needs to be done, note which blocks contain 30 * directory information, since we will need to 31 * update the directory information. 32 * 4. Update the directory blocks with the new inode locations. 33 * 5. Move the inode tables, if necessary. 34 */ 35 36#include "config.h" 37#include "resize2fs.h" 38#include <time.h> 39 40#ifdef __linux__ /* Kludge for debugging */ 41#define RESIZE2FS_DEBUG 42#endif 43 44static void fix_uninit_block_bitmaps(ext2_filsys fs); 45static errcode_t adjust_superblock(ext2_resize_t rfs, blk64_t new_size); 46static errcode_t blocks_to_move(ext2_resize_t rfs); 47static errcode_t block_mover(ext2_resize_t rfs); 48static errcode_t inode_scan_and_fix(ext2_resize_t rfs); 49static errcode_t inode_ref_fix(ext2_resize_t rfs); 50static errcode_t move_itables(ext2_resize_t rfs); 51static errcode_t fix_resize_inode(ext2_filsys fs); 52static errcode_t ext2fs_calculate_summary_stats(ext2_filsys fs); 53static errcode_t fix_sb_journal_backup(ext2_filsys fs); 54 55/* 56 * Some helper CPP macros 57 */ 58#define IS_BLOCK_BM(fs, i, blk) ((blk) == ext2fs_block_bitmap_loc((fs),(i))) 59#define IS_INODE_BM(fs, i, blk) ((blk) == ext2fs_inode_bitmap_loc((fs),(i))) 60 61#define IS_INODE_TB(fs, i, blk) (((blk) >= ext2fs_inode_table_loc((fs), (i))) && \ 62 ((blk) < (ext2fs_inode_table_loc((fs), (i)) + \ 63 (fs)->inode_blocks_per_group))) 64 65int lazy_itable_init; 66 67/* 68 * This is the top-level routine which does the dirty deed.... 69 */ 70errcode_t resize_fs(ext2_filsys fs, blk64_t *new_size, int flags, 71 errcode_t (*progress)(ext2_resize_t rfs, int pass, 72 unsigned long cur, 73 unsigned long max_val)) 74{ 75 ext2_resize_t rfs; 76 errcode_t retval; 77 78 retval = ext2fs_read_bitmaps(fs); 79 if (retval) 80 return retval; 81 82 fs->super->s_state |= EXT2_ERROR_FS; 83 ext2fs_mark_super_dirty(fs); 84 ext2fs_flush(fs); 85 86 /* 87 * Create the data structure 88 */ 89 retval = ext2fs_get_mem(sizeof(struct ext2_resize_struct), &rfs); 90 if (retval) 91 return retval; 92 memset(rfs, 0, sizeof(struct ext2_resize_struct)); 93 94 fix_uninit_block_bitmaps(fs); 95 fs->priv_data = rfs; 96 rfs->old_fs = fs; 97 rfs->flags = flags; 98 rfs->itable_buf = 0; 99 rfs->progress = progress; 100 retval = ext2fs_dup_handle(fs, &rfs->new_fs); 101 if (retval) 102 goto errout; 103 104 retval = adjust_superblock(rfs, *new_size); 105 if (retval) 106 goto errout; 107 108 fix_uninit_block_bitmaps(rfs->new_fs); 109 /* Clear the block bitmap uninit flag for the last block group */ 110 ext2fs_bg_flags_clear(rfs->new_fs, rfs->new_fs->group_desc_count - 1, 111 EXT2_BG_BLOCK_UNINIT); 112 113 *new_size = ext2fs_blocks_count(rfs->new_fs->super); 114 115 retval = blocks_to_move(rfs); 116 if (retval) 117 goto errout; 118 119#ifdef RESIZE2FS_DEBUG 120 if (rfs->flags & RESIZE_DEBUG_BMOVE) 121 printf("Number of free blocks: %llu/%llu, Needed: %llu\n", 122 ext2fs_free_blocks_count(rfs->old_fs->super), 123 ext2fs_free_blocks_count(rfs->new_fs->super), 124 rfs->needed_blocks); 125#endif 126 127 retval = block_mover(rfs); 128 if (retval) 129 goto errout; 130 131 retval = inode_scan_and_fix(rfs); 132 if (retval) 133 goto errout; 134 135 retval = inode_ref_fix(rfs); 136 if (retval) 137 goto errout; 138 139 retval = move_itables(rfs); 140 if (retval) 141 goto errout; 142 143 retval = ext2fs_calculate_summary_stats(rfs->new_fs); 144 if (retval) 145 goto errout; 146 147 retval = fix_resize_inode(rfs->new_fs); 148 if (retval) 149 goto errout; 150 151 retval = fix_sb_journal_backup(rfs->new_fs); 152 if (retval) 153 goto errout; 154 155 rfs->new_fs->super->s_state &= ~EXT2_ERROR_FS; 156 rfs->new_fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; 157 retval = ext2fs_close(rfs->new_fs); 158 if (retval) 159 goto errout; 160 161 rfs->flags = flags; 162 163 ext2fs_free(rfs->old_fs); 164 if (rfs->itable_buf) 165 ext2fs_free_mem(&rfs->itable_buf); 166 if (rfs->reserve_blocks) 167 ext2fs_free_block_bitmap(rfs->reserve_blocks); 168 if (rfs->move_blocks) 169 ext2fs_free_block_bitmap(rfs->move_blocks); 170 ext2fs_free_mem(&rfs); 171 172 return 0; 173 174errout: 175 if (rfs->new_fs) 176 ext2fs_free(rfs->new_fs); 177 if (rfs->itable_buf) 178 ext2fs_free_mem(&rfs->itable_buf); 179 ext2fs_free_mem(&rfs); 180 return retval; 181} 182 183/* 184 * Clean up the bitmaps for unitialized bitmaps 185 */ 186static void fix_uninit_block_bitmaps(ext2_filsys fs) 187{ 188 blk64_t i, blk, super_blk, old_desc_blk, new_desc_blk; 189 int old_desc_blocks; 190 dgrp_t g; 191 192 if (!(EXT2_HAS_RO_COMPAT_FEATURE(fs->super, 193 EXT4_FEATURE_RO_COMPAT_GDT_CSUM))) 194 return; 195 196 for (g=0; g < fs->group_desc_count; g++) { 197 if (!(ext2fs_bg_flags_test(fs, g, EXT2_BG_BLOCK_UNINIT))) 198 continue; 199 200 blk = (g * fs->super->s_blocks_per_group) + 201 fs->super->s_first_data_block; 202 203 ext2fs_super_and_bgd_loc2(fs, g, &super_blk, 204 &old_desc_blk, &new_desc_blk, 0); 205 206 if (fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_META_BG) 207 old_desc_blocks = fs->super->s_first_meta_bg; 208 else 209 old_desc_blocks = fs->desc_blocks + 210 fs->super->s_reserved_gdt_blocks; 211 212 for (i=0; i < fs->super->s_blocks_per_group; i++, blk++) { 213 if (blk >= ext2fs_blocks_count(fs->super)) 214 break; 215 if ((blk == super_blk) || 216 (old_desc_blk && old_desc_blocks && 217 (blk >= old_desc_blk) && 218 (blk < old_desc_blk + old_desc_blocks)) || 219 (new_desc_blk && (blk == new_desc_blk)) || 220 (blk == ext2fs_block_bitmap_loc(fs, g)) || 221 (blk == ext2fs_inode_bitmap_loc(fs, g)) || 222 (blk >= ext2fs_inode_table_loc(fs, g) && 223 (blk < ext2fs_inode_table_loc(fs, g) 224 + fs->inode_blocks_per_group))) 225 ext2fs_fast_mark_block_bitmap2(fs->block_map, blk); 226 else 227 ext2fs_fast_unmark_block_bitmap2(fs->block_map, blk); 228 } 229 } 230} 231 232/* -------------------------------------------------------------------- 233 * 234 * Resize processing, phase 1. 235 * 236 * In this phase we adjust the in-memory superblock information, and 237 * initialize any new parts of the inode table. The new parts of the 238 * inode table are created in virgin disk space, so we can abort here 239 * without any side effects. 240 * -------------------------------------------------------------------- 241 */ 242 243/* 244 * If the group descriptor's bitmap and inode table blocks are valid, 245 * release them in the new filesystem data structure, and mark them as 246 * reserved so the old inode table blocks don't get overwritten. 247 */ 248static void free_gdp_blocks(ext2_filsys fs, 249 ext2fs_block_bitmap reserve_blocks, 250 struct ext2_group_desc *gdp) 251{ 252 blk_t blk; 253 int j; 254 255 if (gdp->bg_block_bitmap && 256 (gdp->bg_block_bitmap < ext2fs_blocks_count(fs->super))) { 257 ext2fs_block_alloc_stats(fs, gdp->bg_block_bitmap, -1); 258 ext2fs_mark_block_bitmap2(reserve_blocks, 259 gdp->bg_block_bitmap); 260 } 261 262 if (gdp->bg_inode_bitmap && 263 (gdp->bg_inode_bitmap < ext2fs_blocks_count(fs->super))) { 264 ext2fs_block_alloc_stats(fs, gdp->bg_inode_bitmap, -1); 265 ext2fs_mark_block_bitmap2(reserve_blocks, 266 gdp->bg_inode_bitmap); 267 } 268 269 if (gdp->bg_inode_table == 0 || 270 (gdp->bg_inode_table >= ext2fs_blocks_count(fs->super))) 271 return; 272 273 for (blk = gdp->bg_inode_table, j = 0; 274 j < fs->inode_blocks_per_group; j++, blk++) { 275 if (blk >= ext2fs_blocks_count(fs->super)) 276 break; 277 ext2fs_block_alloc_stats(fs, blk, -1); 278 ext2fs_mark_block_bitmap2(reserve_blocks, blk); 279 } 280} 281 282/* 283 * This routine is shared by the online and offline resize routines. 284 * All of the information which is adjusted in memory is done here. 285 * 286 * The reserve_blocks parameter is only needed when shrinking the 287 * filesystem. 288 */ 289errcode_t adjust_fs_info(ext2_filsys fs, ext2_filsys old_fs, 290 ext2fs_block_bitmap reserve_blocks, blk64_t new_size) 291{ 292 errcode_t retval; 293 blk64_t overhead = 0; 294 blk64_t rem; 295 blk64_t blk, group_block; 296 blk64_t real_end; 297 blk64_t old_numblocks, numblocks, adjblocks; 298 unsigned long i, j, old_desc_blocks; 299 unsigned int meta_bg, meta_bg_size; 300 int has_super, csum_flag; 301 unsigned long long new_inodes; /* u64 to check for overflow */ 302 double percent; 303 304 ext2fs_blocks_count_set(fs->super, new_size); 305 306retry: 307 fs->group_desc_count = ext2fs_div64_ceil(ext2fs_blocks_count(fs->super) - 308 fs->super->s_first_data_block, 309 EXT2_BLOCKS_PER_GROUP(fs->super)); 310 if (fs->group_desc_count == 0) 311 return EXT2_ET_TOOSMALL; 312 fs->desc_blocks = ext2fs_div_ceil(fs->group_desc_count, 313 EXT2_DESC_PER_BLOCK(fs->super)); 314 315 /* 316 * Overhead is the number of bookkeeping blocks per group. It 317 * includes the superblock backup, the group descriptor 318 * backups, the inode bitmap, the block bitmap, and the inode 319 * table. 320 */ 321 overhead = (int) (2 + fs->inode_blocks_per_group); 322 323 if (ext2fs_bg_has_super(fs, fs->group_desc_count - 1)) 324 overhead += 1 + fs->desc_blocks + 325 fs->super->s_reserved_gdt_blocks; 326 327 /* 328 * See if the last group is big enough to support the 329 * necessary data structures. If not, we need to get rid of 330 * it. 331 */ 332 rem = (ext2fs_blocks_count(fs->super) - fs->super->s_first_data_block) % 333 fs->super->s_blocks_per_group; 334 if ((fs->group_desc_count == 1) && rem && (rem < overhead)) 335 return EXT2_ET_TOOSMALL; 336 if ((fs->group_desc_count > 1) && rem && (rem < overhead+50)) { 337 ext2fs_blocks_count_set(fs->super, 338 ext2fs_blocks_count(fs->super) - rem); 339 goto retry; 340 } 341 /* 342 * Adjust the number of inodes 343 */ 344 new_inodes =(unsigned long long) fs->super->s_inodes_per_group * fs->group_desc_count; 345 if (new_inodes > ~0U) { 346 fprintf(stderr, _("inodes (%llu) must be less than %u"), 347 new_inodes, ~0U); 348 return EXT2_ET_TOO_MANY_INODES; 349 } 350 fs->super->s_inodes_count = fs->super->s_inodes_per_group * 351 fs->group_desc_count; 352 353 /* 354 * Adjust the number of free blocks 355 */ 356 blk = ext2fs_blocks_count(old_fs->super); 357 if (blk > ext2fs_blocks_count(fs->super)) 358 ext2fs_free_blocks_count_set(fs->super, 359 ext2fs_free_blocks_count(fs->super) - 360 (blk - ext2fs_blocks_count(fs->super))); 361 else 362 ext2fs_free_blocks_count_set(fs->super, 363 ext2fs_free_blocks_count(fs->super) + 364 (ext2fs_blocks_count(fs->super) - blk)); 365 366 /* 367 * Adjust the number of reserved blocks 368 */ 369 percent = (ext2fs_r_blocks_count(old_fs->super) * 100.0) / 370 ext2fs_blocks_count(old_fs->super); 371 ext2fs_r_blocks_count_set(fs->super, 372 (percent * ext2fs_blocks_count(fs->super) / 373 100.0)); 374 375 /* 376 * Adjust the bitmaps for size 377 */ 378 retval = ext2fs_resize_inode_bitmap2(fs->super->s_inodes_count, 379 fs->super->s_inodes_count, 380 fs->inode_map); 381 if (retval) goto errout; 382 383 real_end = (((blk64_t) EXT2_BLOCKS_PER_GROUP(fs->super) * 384 fs->group_desc_count)) - 1 + 385 fs->super->s_first_data_block; 386 retval = ext2fs_resize_block_bitmap2(ext2fs_blocks_count(fs->super)-1, 387 real_end, fs->block_map); 388 389 if (retval) goto errout; 390 391 /* 392 * Reallocate the group descriptors as necessary. 393 */ 394 if (old_fs->desc_blocks != fs->desc_blocks) { 395 retval = ext2fs_resize_mem(old_fs->desc_blocks * 396 fs->blocksize, 397 fs->desc_blocks * fs->blocksize, 398 &fs->group_desc); 399 if (retval) 400 goto errout; 401 if (fs->desc_blocks > old_fs->desc_blocks) 402 memset((char *) fs->group_desc + 403 (old_fs->desc_blocks * fs->blocksize), 0, 404 (fs->desc_blocks - old_fs->desc_blocks) * 405 fs->blocksize); 406 } 407 408 /* 409 * If the resize_inode feature is set, and we are changing the 410 * number of descriptor blocks, then adjust 411 * s_reserved_gdt_blocks if possible to avoid needing to move 412 * the inode table either now or in the future. 413 */ 414 if ((fs->super->s_feature_compat & 415 EXT2_FEATURE_COMPAT_RESIZE_INODE) && 416 (old_fs->desc_blocks != fs->desc_blocks)) { 417 int new; 418 419 new = ((int) fs->super->s_reserved_gdt_blocks) + 420 (old_fs->desc_blocks - fs->desc_blocks); 421 if (new < 0) 422 new = 0; 423 if (new > (int) fs->blocksize/4) 424 new = fs->blocksize/4; 425 fs->super->s_reserved_gdt_blocks = new; 426 } 427 428 /* 429 * If we are shrinking the number of block groups, we're done 430 * and can exit now. 431 */ 432 if (old_fs->group_desc_count > fs->group_desc_count) { 433 /* 434 * Check the block groups that we are chopping off 435 * and free any blocks associated with their metadata 436 */ 437 for (i = fs->group_desc_count; 438 i < old_fs->group_desc_count; i++) { 439 free_gdp_blocks(fs, reserve_blocks, 440 ext2fs_group_desc(old_fs, 441 old_fs->group_desc, i)); 442 } 443 retval = 0; 444 goto errout; 445 } 446 447 /* 448 * Fix the count of the last (old) block group 449 */ 450 old_numblocks = (ext2fs_blocks_count(old_fs->super) - 451 old_fs->super->s_first_data_block) % 452 old_fs->super->s_blocks_per_group; 453 if (!old_numblocks) 454 old_numblocks = old_fs->super->s_blocks_per_group; 455 if (old_fs->group_desc_count == fs->group_desc_count) { 456 numblocks = (ext2fs_blocks_count(fs->super) - 457 fs->super->s_first_data_block) % 458 fs->super->s_blocks_per_group; 459 if (!numblocks) 460 numblocks = fs->super->s_blocks_per_group; 461 } else 462 numblocks = fs->super->s_blocks_per_group; 463 i = old_fs->group_desc_count - 1; 464 ext2fs_bg_free_blocks_count_set(fs, i, ext2fs_bg_free_blocks_count(fs, i) + (numblocks - old_numblocks)); 465 ext2fs_group_desc_csum_set(fs, i); 466 467 /* 468 * If the number of block groups is staying the same, we're 469 * done and can exit now. (If the number block groups is 470 * shrinking, we had exited earlier.) 471 */ 472 if (old_fs->group_desc_count >= fs->group_desc_count) { 473 retval = 0; 474 goto errout; 475 } 476 477 /* 478 * Initialize the new block group descriptors 479 */ 480 group_block = fs->super->s_first_data_block + 481 old_fs->group_desc_count * fs->super->s_blocks_per_group; 482 483 csum_flag = EXT2_HAS_RO_COMPAT_FEATURE(fs->super, 484 EXT4_FEATURE_RO_COMPAT_GDT_CSUM); 485 if (access("/sys/fs/ext4/features/lazy_itable_init", F_OK) == 0) 486 lazy_itable_init = 1; 487 if (fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_META_BG) 488 old_desc_blocks = fs->super->s_first_meta_bg; 489 else 490 old_desc_blocks = fs->desc_blocks + 491 fs->super->s_reserved_gdt_blocks; 492 for (i = old_fs->group_desc_count; 493 i < fs->group_desc_count; i++) { 494 memset(ext2fs_group_desc(fs, fs->group_desc, i), 0, 495 sizeof(struct ext2_group_desc)); 496 adjblocks = 0; 497 498 ext2fs_bg_flags_zap(fs, i); 499 if (csum_flag) { 500 ext2fs_bg_flags_set(fs, i, EXT2_BG_INODE_UNINIT); 501 if (!lazy_itable_init) 502 ext2fs_bg_flags_set(fs, i, 503 EXT2_BG_INODE_ZEROED); 504 ext2fs_bg_itable_unused_set(fs, i, 505 fs->super->s_inodes_per_group); 506 } 507 508 numblocks = ext2fs_group_blocks_count(fs, i); 509 if ((i < fs->group_desc_count - 1) && csum_flag) 510 ext2fs_bg_flags_set(fs, i, EXT2_BG_BLOCK_UNINIT); 511 512 has_super = ext2fs_bg_has_super(fs, i); 513 if (has_super) { 514 ext2fs_block_alloc_stats2(fs, group_block, +1); 515 adjblocks++; 516 } 517 meta_bg_size = EXT2_DESC_PER_BLOCK(fs->super); 518 meta_bg = i / meta_bg_size; 519 if (!(fs->super->s_feature_incompat & 520 EXT2_FEATURE_INCOMPAT_META_BG) || 521 (meta_bg < fs->super->s_first_meta_bg)) { 522 if (has_super) { 523 for (j=0; j < old_desc_blocks; j++) 524 ext2fs_block_alloc_stats2(fs, 525 group_block + 1 + j, +1); 526 adjblocks += old_desc_blocks; 527 } 528 } else { 529 if (has_super) 530 has_super = 1; 531 if (((i % meta_bg_size) == 0) || 532 ((i % meta_bg_size) == 1) || 533 ((i % meta_bg_size) == (meta_bg_size-1))) 534 ext2fs_block_alloc_stats2(fs, 535 group_block + has_super, +1); 536 } 537 538 adjblocks += 2 + fs->inode_blocks_per_group; 539 540 numblocks -= adjblocks; 541 ext2fs_free_blocks_count_set(fs->super, 542 ext2fs_free_blocks_count(fs->super) - adjblocks); 543 fs->super->s_free_inodes_count += 544 fs->super->s_inodes_per_group; 545 ext2fs_bg_free_blocks_count_set(fs, i, numblocks); 546 ext2fs_bg_free_inodes_count_set(fs, i, 547 fs->super->s_inodes_per_group); 548 ext2fs_bg_used_dirs_count_set(fs, i, 0); 549 ext2fs_group_desc_csum_set(fs, i); 550 551 retval = ext2fs_allocate_group_table(fs, i, 0); 552 if (retval) goto errout; 553 554 group_block += fs->super->s_blocks_per_group; 555 } 556 retval = 0; 557 558errout: 559 return (retval); 560} 561 562/* 563 * This routine adjusts the superblock and other data structures, both 564 * in disk as well as in memory... 565 */ 566static errcode_t adjust_superblock(ext2_resize_t rfs, blk64_t new_size) 567{ 568 ext2_filsys fs; 569 int adj = 0; 570 errcode_t retval; 571 blk64_t group_block; 572 unsigned long i; 573 unsigned long max_group; 574 575 fs = rfs->new_fs; 576 ext2fs_mark_super_dirty(fs); 577 ext2fs_mark_bb_dirty(fs); 578 ext2fs_mark_ib_dirty(fs); 579 580 retval = ext2fs_allocate_block_bitmap(fs, _("reserved blocks"), 581 &rfs->reserve_blocks); 582 if (retval) 583 return retval; 584 585 retval = adjust_fs_info(fs, rfs->old_fs, rfs->reserve_blocks, new_size); 586 if (retval) 587 goto errout; 588 589 /* 590 * Check to make sure there are enough inodes 591 */ 592 if ((rfs->old_fs->super->s_inodes_count - 593 rfs->old_fs->super->s_free_inodes_count) > 594 rfs->new_fs->super->s_inodes_count) { 595 retval = ENOSPC; 596 goto errout; 597 } 598 599 /* 600 * If we are shrinking the number block groups, we're done and 601 * can exit now. 602 */ 603 if (rfs->old_fs->group_desc_count > fs->group_desc_count) { 604 retval = 0; 605 goto errout; 606 } 607 608 /* 609 * If the number of block groups is staying the same, we're 610 * done and can exit now. (If the number block groups is 611 * shrinking, we had exited earlier.) 612 */ 613 if (rfs->old_fs->group_desc_count >= fs->group_desc_count) { 614 retval = 0; 615 goto errout; 616 } 617 618 /* 619 * If we are using uninit_bg (aka GDT_CSUM) and the kernel 620 * supports lazy inode initialization, we can skip 621 * initializing the inode table. 622 */ 623 if (lazy_itable_init && 624 EXT2_HAS_RO_COMPAT_FEATURE(fs->super, 625 EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) { 626 retval = 0; 627 goto errout; 628 } 629 630 /* 631 * Initialize the inode table 632 */ 633 retval = ext2fs_get_array(fs->blocksize, fs->inode_blocks_per_group, 634 &rfs->itable_buf); 635 if (retval) 636 goto errout; 637 638 memset(rfs->itable_buf, 0, fs->blocksize * fs->inode_blocks_per_group); 639 group_block = fs->super->s_first_data_block + 640 rfs->old_fs->group_desc_count * fs->super->s_blocks_per_group; 641 642 adj = rfs->old_fs->group_desc_count; 643 max_group = fs->group_desc_count - adj; 644 if (rfs->progress) { 645 retval = rfs->progress(rfs, E2_RSZ_EXTEND_ITABLE_PASS, 646 0, max_group); 647 if (retval) 648 goto errout; 649 } 650 for (i = rfs->old_fs->group_desc_count; 651 i < fs->group_desc_count; i++) { 652 /* 653 * Write out the new inode table 654 */ 655 retval = io_channel_write_blk64(fs->io, 656 ext2fs_inode_table_loc(fs, i), 657 fs->inode_blocks_per_group, 658 rfs->itable_buf); 659 if (retval) goto errout; 660 661 io_channel_flush(fs->io); 662 if (rfs->progress) { 663 retval = rfs->progress(rfs, E2_RSZ_EXTEND_ITABLE_PASS, 664 i - adj + 1, max_group); 665 if (retval) 666 goto errout; 667 } 668 group_block += fs->super->s_blocks_per_group; 669 } 670 io_channel_flush(fs->io); 671 retval = 0; 672 673errout: 674 return retval; 675} 676 677/* -------------------------------------------------------------------- 678 * 679 * Resize processing, phase 2. 680 * 681 * In this phase we adjust determine which blocks need to be moved, in 682 * blocks_to_move(). We then copy the blocks to their ultimate new 683 * destinations using block_mover(). Since we are copying blocks to 684 * their new locations, again during this pass we can abort without 685 * any problems. 686 * -------------------------------------------------------------------- 687 */ 688 689/* 690 * This helper function creates a block bitmap with all of the 691 * filesystem meta-data blocks. 692 */ 693static errcode_t mark_table_blocks(ext2_filsys fs, 694 ext2fs_block_bitmap bmap) 695{ 696 blk64_t b; 697 unsigned int j; 698 dgrp_t i; 699 700 for (i = 0; i < fs->group_desc_count; i++) { 701 ext2fs_reserve_super_and_bgd(fs, i, bmap); 702 703 /* 704 * Mark the blocks used for the inode table 705 */ 706 for (j = 0, b = ext2fs_inode_table_loc(fs, i); 707 j < (unsigned int) fs->inode_blocks_per_group; 708 j++, b++) 709 ext2fs_mark_block_bitmap2(bmap, b); 710 711 /* 712 * Mark block used for the block bitmap 713 */ 714 ext2fs_mark_block_bitmap2(bmap, 715 ext2fs_block_bitmap_loc(fs, i)); 716 717 /* 718 * Mark block used for the inode bitmap 719 */ 720 ext2fs_mark_block_bitmap2(bmap, 721 ext2fs_inode_bitmap_loc(fs, i)); 722 } 723 return 0; 724} 725 726/* 727 * This function checks to see if a particular block (either a 728 * superblock or a block group descriptor) overlaps with an inode or 729 * block bitmap block, or with the inode table. 730 */ 731static void mark_fs_metablock(ext2_resize_t rfs, 732 ext2fs_block_bitmap meta_bmap, 733 int group, blk64_t blk) 734{ 735 ext2_filsys fs = rfs->new_fs; 736 737 ext2fs_mark_block_bitmap2(rfs->reserve_blocks, blk); 738 ext2fs_block_alloc_stats2(fs, blk, +1); 739 740 /* 741 * Check to see if we overlap with the inode or block bitmap, 742 * or the inode tables. If not, and the block is in use, then 743 * mark it as a block to be moved. 744 */ 745 if (IS_BLOCK_BM(fs, group, blk)) { 746 ext2fs_block_bitmap_loc_set(fs, group, 0); 747 rfs->needed_blocks++; 748 } else if (IS_INODE_BM(fs, group, blk)) { 749 ext2fs_inode_bitmap_loc_set(fs, group, 0); 750 rfs->needed_blocks++; 751 } else if (IS_INODE_TB(fs, group, blk)) { 752 ext2fs_inode_table_loc_set(fs, group, 0); 753 rfs->needed_blocks++; 754 } else if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super, 755 EXT4_FEATURE_RO_COMPAT_GDT_CSUM) && 756 (ext2fs_bg_flags_test(fs, group, EXT2_BG_BLOCK_UNINIT))) { 757 /* 758 * If the block bitmap is uninitialized, which means 759 * nothing other than standard metadata in use. 760 */ 761 return; 762 } else if (ext2fs_test_block_bitmap2(rfs->old_fs->block_map, blk) && 763 !ext2fs_test_block_bitmap2(meta_bmap, blk)) { 764 ext2fs_mark_block_bitmap2(rfs->move_blocks, blk); 765 rfs->needed_blocks++; 766 } 767} 768 769 770/* 771 * This routine marks and unmarks reserved blocks in the new block 772 * bitmap. It also determines which blocks need to be moved and 773 * places this information into the move_blocks bitmap. 774 */ 775static errcode_t blocks_to_move(ext2_resize_t rfs) 776{ 777 int j, has_super; 778 dgrp_t i, max_groups, g; 779 blk64_t blk, group_blk; 780 blk64_t old_blocks, new_blocks; 781 unsigned int meta_bg, meta_bg_size; 782 errcode_t retval; 783 ext2_filsys fs, old_fs; 784 ext2fs_block_bitmap meta_bmap; 785 __u32 save_incompat_flag; 786 787 fs = rfs->new_fs; 788 old_fs = rfs->old_fs; 789 if (ext2fs_blocks_count(old_fs->super) > ext2fs_blocks_count(fs->super)) 790 fs = rfs->old_fs; 791 792 retval = ext2fs_allocate_block_bitmap(fs, _("blocks to be moved"), 793 &rfs->move_blocks); 794 if (retval) 795 return retval; 796 797 retval = ext2fs_allocate_block_bitmap(fs, _("meta-data blocks"), 798 &meta_bmap); 799 if (retval) 800 return retval; 801 802 retval = mark_table_blocks(old_fs, meta_bmap); 803 if (retval) 804 return retval; 805 806 fs = rfs->new_fs; 807 808 /* 809 * If we're shrinking the filesystem, we need to move all of 810 * the blocks that don't fit any more 811 */ 812 for (blk = ext2fs_blocks_count(fs->super); 813 blk < ext2fs_blocks_count(old_fs->super); blk++) { 814 g = ext2fs_group_of_blk2(fs, blk); 815 if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super, 816 EXT4_FEATURE_RO_COMPAT_GDT_CSUM) && 817 ext2fs_bg_flags_test(old_fs, g, EXT2_BG_BLOCK_UNINIT)) { 818 /* 819 * The block bitmap is uninitialized, so skip 820 * to the next block group. 821 */ 822 blk = ((g+1) * fs->super->s_blocks_per_group) + 823 fs->super->s_first_data_block - 1; 824 continue; 825 } 826 if (ext2fs_test_block_bitmap2(old_fs->block_map, blk) && 827 !ext2fs_test_block_bitmap2(meta_bmap, blk)) { 828 ext2fs_mark_block_bitmap2(rfs->move_blocks, blk); 829 rfs->needed_blocks++; 830 } 831 ext2fs_mark_block_bitmap2(rfs->reserve_blocks, blk); 832 } 833 834 if (fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_META_BG) { 835 old_blocks = old_fs->super->s_first_meta_bg; 836 new_blocks = fs->super->s_first_meta_bg; 837 } else { 838 old_blocks = old_fs->desc_blocks + old_fs->super->s_reserved_gdt_blocks; 839 new_blocks = fs->desc_blocks + fs->super->s_reserved_gdt_blocks; 840 } 841 842 if (old_blocks == new_blocks) { 843 retval = 0; 844 goto errout; 845 } 846 847 max_groups = fs->group_desc_count; 848 if (max_groups > old_fs->group_desc_count) 849 max_groups = old_fs->group_desc_count; 850 group_blk = old_fs->super->s_first_data_block; 851 /* 852 * If we're reducing the number of descriptor blocks, this 853 * makes life easy. :-) We just have to mark some extra 854 * blocks as free. 855 */ 856 if (old_blocks > new_blocks) { 857 for (i = 0; i < max_groups; i++) { 858 if (!ext2fs_bg_has_super(fs, i)) { 859 group_blk += fs->super->s_blocks_per_group; 860 continue; 861 } 862 for (blk = group_blk+1+new_blocks; 863 blk < group_blk+1+old_blocks; blk++) { 864 ext2fs_block_alloc_stats2(fs, blk, -1); 865 rfs->needed_blocks--; 866 } 867 group_blk += fs->super->s_blocks_per_group; 868 } 869 retval = 0; 870 goto errout; 871 } 872 /* 873 * If we're increasing the number of descriptor blocks, life 874 * gets interesting.... 875 */ 876 meta_bg_size = EXT2_DESC_PER_BLOCK(fs->super); 877 for (i = 0; i < max_groups; i++) { 878 has_super = ext2fs_bg_has_super(fs, i); 879 if (has_super) 880 mark_fs_metablock(rfs, meta_bmap, i, group_blk); 881 882 meta_bg = i / meta_bg_size; 883 if (!(fs->super->s_feature_incompat & 884 EXT2_FEATURE_INCOMPAT_META_BG) || 885 (meta_bg < fs->super->s_first_meta_bg)) { 886 if (has_super) { 887 for (blk = group_blk+1; 888 blk < group_blk + 1 + new_blocks; blk++) 889 mark_fs_metablock(rfs, meta_bmap, 890 i, blk); 891 } 892 } else { 893 if (has_super) 894 has_super = 1; 895 if (((i % meta_bg_size) == 0) || 896 ((i % meta_bg_size) == 1) || 897 ((i % meta_bg_size) == (meta_bg_size-1))) 898 mark_fs_metablock(rfs, meta_bmap, i, 899 group_blk + has_super); 900 } 901 902 if (ext2fs_inode_table_loc(fs, i) && 903 ext2fs_inode_bitmap_loc(fs, i) && 904 ext2fs_block_bitmap_loc(fs, i)) 905 goto next_group; 906 907 /* 908 * Reserve the existing meta blocks that we know 909 * aren't to be moved. 910 */ 911 if (ext2fs_block_bitmap_loc(fs, i)) 912 ext2fs_mark_block_bitmap2(rfs->reserve_blocks, 913 ext2fs_block_bitmap_loc(fs, i)); 914 if (ext2fs_inode_bitmap_loc(fs, i)) 915 ext2fs_mark_block_bitmap2(rfs->reserve_blocks, 916 ext2fs_inode_bitmap_loc(fs, i)); 917 if (ext2fs_inode_table_loc(fs, i)) 918 for (blk = ext2fs_inode_table_loc(fs, i), j=0; 919 j < fs->inode_blocks_per_group ; j++, blk++) 920 ext2fs_mark_block_bitmap2(rfs->reserve_blocks, 921 blk); 922 923 /* 924 * Allocate the missing data structures 925 * 926 * XXX We have a problem with FLEX_BG and off-line 927 * resizing where we are growing the size of the 928 * filesystem. ext2fs_allocate_group_table() will try 929 * to reserve the inode table in the desired flex_bg 930 * location. However, passing rfs->reserve_blocks 931 * doesn't work since it only has reserved the blocks 932 * that will be used in the new block group -- and 933 * with flex_bg, we can and will allocate the tables 934 * outside of the block group. And we can't pass in 935 * the fs->block_map because it doesn't handle 936 * overlapping inode table movements right. So for 937 * now, we temporarily disable flex_bg to force 938 * ext2fs_allocate_group_tables() to allocate the bg 939 * metadata in side the block group, and the restore 940 * it afterwards. Ugly, until we can fix this up 941 * right later. 942 */ 943 save_incompat_flag = fs->super->s_feature_incompat; 944 fs->super->s_feature_incompat &= ~EXT4_FEATURE_INCOMPAT_FLEX_BG; 945 retval = ext2fs_allocate_group_table(fs, i, 946 rfs->reserve_blocks); 947 fs->super->s_feature_incompat = save_incompat_flag; 948 if (retval) 949 goto errout; 950 951 /* 952 * For those structures that have changed, we need to 953 * do bookkeepping. 954 */ 955 if (ext2fs_block_bitmap_loc(old_fs, i) != 956 (blk = ext2fs_block_bitmap_loc(fs, i))) { 957 ext2fs_block_alloc_stats2(fs, blk, +1); 958 if (ext2fs_test_block_bitmap2(old_fs->block_map, blk) && 959 !ext2fs_test_block_bitmap2(meta_bmap, blk)) 960 ext2fs_mark_block_bitmap2(rfs->move_blocks, 961 blk); 962 } 963 if (ext2fs_inode_bitmap_loc(old_fs, i) != 964 (blk = ext2fs_inode_bitmap_loc(fs, i))) { 965 ext2fs_block_alloc_stats2(fs, blk, +1); 966 if (ext2fs_test_block_bitmap2(old_fs->block_map, blk) && 967 !ext2fs_test_block_bitmap2(meta_bmap, blk)) 968 ext2fs_mark_block_bitmap2(rfs->move_blocks, 969 blk); 970 } 971 972 /* 973 * The inode table, if we need to relocate it, is 974 * handled specially. We have to reserve the blocks 975 * for both the old and the new inode table, since we 976 * can't have the inode table be destroyed during the 977 * block relocation phase. 978 */ 979 if (ext2fs_inode_table_loc(fs, i) == ext2fs_inode_table_loc(old_fs, i)) 980 goto next_group; /* inode table not moved */ 981 982 rfs->needed_blocks += fs->inode_blocks_per_group; 983 984 /* 985 * Mark the new inode table as in use in the new block 986 * allocation bitmap, and move any blocks that might 987 * be necessary. 988 */ 989 for (blk = ext2fs_inode_table_loc(fs, i), j=0; 990 j < fs->inode_blocks_per_group ; j++, blk++) { 991 ext2fs_block_alloc_stats2(fs, blk, +1); 992 if (ext2fs_test_block_bitmap2(old_fs->block_map, blk) && 993 !ext2fs_test_block_bitmap2(meta_bmap, blk)) 994 ext2fs_mark_block_bitmap2(rfs->move_blocks, 995 blk); 996 } 997 998 /* 999 * Make sure the old inode table is reserved in the 1000 * block reservation bitmap. 1001 */ 1002 for (blk = ext2fs_inode_table_loc(rfs->old_fs, i), j=0; 1003 j < fs->inode_blocks_per_group ; j++, blk++) 1004 ext2fs_mark_block_bitmap2(rfs->reserve_blocks, blk); 1005 1006 next_group: 1007 group_blk += rfs->new_fs->super->s_blocks_per_group; 1008 } 1009 retval = 0; 1010 1011errout: 1012 if (meta_bmap) 1013 ext2fs_free_block_bitmap(meta_bmap); 1014 1015 return retval; 1016} 1017 1018/* 1019 * This helper function tries to allocate a new block. We try to 1020 * avoid hitting the original group descriptor blocks at least at 1021 * first, since we want to make it possible to recover from a badly 1022 * aborted resize operation as much as possible. 1023 * 1024 * In the future, I may further modify this routine to balance out 1025 * where we get the new blocks across the various block groups. 1026 * Ideally we would allocate blocks that corresponded with the block 1027 * group of the containing inode, and keep contiguous blocks 1028 * together. However, this very difficult to do efficiently, since we 1029 * don't have the necessary information up front. 1030 */ 1031 1032#define AVOID_OLD 1 1033#define DESPERATION 2 1034 1035static void init_block_alloc(ext2_resize_t rfs) 1036{ 1037 rfs->alloc_state = AVOID_OLD; 1038 rfs->new_blk = rfs->new_fs->super->s_first_data_block; 1039#if 0 1040 /* HACK for testing */ 1041 if (ext2fs_blocks_count(rfs->new_fs->super) > 1042 ext2fs_blocks_count(rfs->old_fs->super)) 1043 rfs->new_blk = ext2fs_blocks_count(rfs->old_fs->super); 1044#endif 1045} 1046 1047static blk64_t get_new_block(ext2_resize_t rfs) 1048{ 1049 ext2_filsys fs = rfs->new_fs; 1050 1051 while (1) { 1052 if (rfs->new_blk >= ext2fs_blocks_count(fs->super)) { 1053 if (rfs->alloc_state == DESPERATION) 1054 return 0; 1055 1056#ifdef RESIZE2FS_DEBUG 1057 if (rfs->flags & RESIZE_DEBUG_BMOVE) 1058 printf("Going into desperation mode " 1059 "for block allocations\n"); 1060#endif 1061 rfs->alloc_state = DESPERATION; 1062 rfs->new_blk = fs->super->s_first_data_block; 1063 continue; 1064 } 1065 if (ext2fs_test_block_bitmap2(fs->block_map, rfs->new_blk) || 1066 ext2fs_test_block_bitmap2(rfs->reserve_blocks, 1067 rfs->new_blk) || 1068 ((rfs->alloc_state == AVOID_OLD) && 1069 (rfs->new_blk < ext2fs_blocks_count(rfs->old_fs->super)) && 1070 ext2fs_test_block_bitmap2(rfs->old_fs->block_map, 1071 rfs->new_blk))) { 1072 rfs->new_blk++; 1073 continue; 1074 } 1075 return rfs->new_blk; 1076 } 1077} 1078 1079static errcode_t resize2fs_get_alloc_block(ext2_filsys fs, blk64_t goal, 1080 blk64_t *ret) 1081{ 1082 ext2_resize_t rfs = (ext2_resize_t) fs->priv_data; 1083 blk64_t blk; 1084 1085 blk = get_new_block(rfs); 1086 if (!blk) 1087 return ENOSPC; 1088 1089#ifdef RESIZE2FS_DEBUG 1090 if (rfs->flags & 0xF) 1091 printf("get_alloc_block allocating %llu\n", blk); 1092#endif 1093 1094 ext2fs_mark_block_bitmap2(rfs->old_fs->block_map, blk); 1095 ext2fs_mark_block_bitmap2(rfs->new_fs->block_map, blk); 1096 *ret = (blk64_t) blk; 1097 return 0; 1098} 1099 1100static errcode_t block_mover(ext2_resize_t rfs) 1101{ 1102 blk64_t blk, old_blk, new_blk; 1103 ext2_filsys fs = rfs->new_fs; 1104 ext2_filsys old_fs = rfs->old_fs; 1105 errcode_t retval; 1106 __u64 size; 1107 int c; 1108 int to_move, moved; 1109 ext2_badblocks_list badblock_list = 0; 1110 int bb_modified = 0; 1111 1112 fs->get_alloc_block = resize2fs_get_alloc_block; 1113 old_fs->get_alloc_block = resize2fs_get_alloc_block; 1114 1115 retval = ext2fs_read_bb_inode(old_fs, &badblock_list); 1116 if (retval) 1117 return retval; 1118 1119 new_blk = fs->super->s_first_data_block; 1120 if (!rfs->itable_buf) { 1121 retval = ext2fs_get_array(fs->blocksize, 1122 fs->inode_blocks_per_group, 1123 &rfs->itable_buf); 1124 if (retval) 1125 return retval; 1126 } 1127 retval = ext2fs_create_extent_table(&rfs->bmap, 0); 1128 if (retval) 1129 return retval; 1130 1131 /* 1132 * The first step is to figure out where all of the blocks 1133 * will go. 1134 */ 1135 to_move = moved = 0; 1136 init_block_alloc(rfs); 1137 for (blk = old_fs->super->s_first_data_block; 1138 blk < ext2fs_blocks_count(old_fs->super); blk++) { 1139 if (!ext2fs_test_block_bitmap2(old_fs->block_map, blk)) 1140 continue; 1141 if (!ext2fs_test_block_bitmap2(rfs->move_blocks, blk)) 1142 continue; 1143 if (ext2fs_badblocks_list_test(badblock_list, blk)) { 1144 ext2fs_badblocks_list_del(badblock_list, blk); 1145 bb_modified++; 1146 continue; 1147 } 1148 1149 new_blk = get_new_block(rfs); 1150 if (!new_blk) { 1151 retval = ENOSPC; 1152 goto errout; 1153 } 1154 ext2fs_block_alloc_stats2(fs, new_blk, +1); 1155 ext2fs_add_extent_entry(rfs->bmap, blk, new_blk); 1156 to_move++; 1157 } 1158 1159 if (to_move == 0) { 1160 if (rfs->bmap) { 1161 ext2fs_free_extent_table(rfs->bmap); 1162 rfs->bmap = 0; 1163 } 1164 retval = 0; 1165 goto errout; 1166 } 1167 1168 /* 1169 * Step two is to actually move the blocks 1170 */ 1171 retval = ext2fs_iterate_extent(rfs->bmap, 0, 0, 0); 1172 if (retval) goto errout; 1173 1174 if (rfs->progress) { 1175 retval = (rfs->progress)(rfs, E2_RSZ_BLOCK_RELOC_PASS, 1176 0, to_move); 1177 if (retval) 1178 goto errout; 1179 } 1180 while (1) { 1181 retval = ext2fs_iterate_extent(rfs->bmap, &old_blk, &new_blk, &size); 1182 if (retval) goto errout; 1183 if (!size) 1184 break; 1185#ifdef RESIZE2FS_DEBUG 1186 if (rfs->flags & RESIZE_DEBUG_BMOVE) 1187 printf("Moving %llu blocks %llu->%llu\n", 1188 size, old_blk, new_blk); 1189#endif 1190 do { 1191 c = size; 1192 if (c > fs->inode_blocks_per_group) 1193 c = fs->inode_blocks_per_group; 1194 retval = io_channel_read_blk64(fs->io, old_blk, c, 1195 rfs->itable_buf); 1196 if (retval) goto errout; 1197 retval = io_channel_write_blk64(fs->io, new_blk, c, 1198 rfs->itable_buf); 1199 if (retval) goto errout; 1200 size -= c; 1201 new_blk += c; 1202 old_blk += c; 1203 moved += c; 1204 if (rfs->progress) { 1205 io_channel_flush(fs->io); 1206 retval = (rfs->progress)(rfs, 1207 E2_RSZ_BLOCK_RELOC_PASS, 1208 moved, to_move); 1209 if (retval) 1210 goto errout; 1211 } 1212 } while (size > 0); 1213 io_channel_flush(fs->io); 1214 } 1215 1216errout: 1217 if (badblock_list) { 1218 if (!retval && bb_modified) 1219 retval = ext2fs_update_bb_inode(old_fs, 1220 badblock_list); 1221 ext2fs_badblocks_list_free(badblock_list); 1222 } 1223 return retval; 1224} 1225 1226 1227/* -------------------------------------------------------------------- 1228 * 1229 * Resize processing, phase 3 1230 * 1231 * -------------------------------------------------------------------- 1232 */ 1233 1234 1235struct process_block_struct { 1236 ext2_resize_t rfs; 1237 ext2_ino_t ino; 1238 struct ext2_inode * inode; 1239 errcode_t error; 1240 int is_dir; 1241 int changed; 1242}; 1243 1244static int process_block(ext2_filsys fs, blk64_t *block_nr, 1245 e2_blkcnt_t blockcnt, 1246 blk64_t ref_block EXT2FS_ATTR((unused)), 1247 int ref_offset EXT2FS_ATTR((unused)), void *priv_data) 1248{ 1249 struct process_block_struct *pb; 1250 errcode_t retval; 1251 blk64_t block, new_block; 1252 int ret = 0; 1253 1254 pb = (struct process_block_struct *) priv_data; 1255 block = *block_nr; 1256 if (pb->rfs->bmap) { 1257 new_block = ext2fs_extent_translate(pb->rfs->bmap, block); 1258 if (new_block) { 1259 *block_nr = new_block; 1260 ret |= BLOCK_CHANGED; 1261 pb->changed = 1; 1262#ifdef RESIZE2FS_DEBUG 1263 if (pb->rfs->flags & RESIZE_DEBUG_BMOVE) 1264 printf("ino=%u, blockcnt=%lld, %llu->%llu\n", 1265 pb->ino, blockcnt, block, new_block); 1266#endif 1267 block = new_block; 1268 } 1269 } 1270 if (pb->is_dir) { 1271 retval = ext2fs_add_dir_block2(fs->dblist, pb->ino, 1272 block, (int) blockcnt); 1273 if (retval) { 1274 pb->error = retval; 1275 ret |= BLOCK_ABORT; 1276 } 1277 } 1278 return ret; 1279} 1280 1281/* 1282 * Progress callback 1283 */ 1284static errcode_t progress_callback(ext2_filsys fs, 1285 ext2_inode_scan scan EXT2FS_ATTR((unused)), 1286 dgrp_t group, void * priv_data) 1287{ 1288 ext2_resize_t rfs = (ext2_resize_t) priv_data; 1289 errcode_t retval; 1290 1291 /* 1292 * This check is to protect against old ext2 libraries. It 1293 * shouldn't be needed against new libraries. 1294 */ 1295 if ((group+1) == 0) 1296 return 0; 1297 1298 if (rfs->progress) { 1299 io_channel_flush(fs->io); 1300 retval = (rfs->progress)(rfs, E2_RSZ_INODE_SCAN_PASS, 1301 group+1, fs->group_desc_count); 1302 if (retval) 1303 return retval; 1304 } 1305 1306 return 0; 1307} 1308 1309static errcode_t inode_scan_and_fix(ext2_resize_t rfs) 1310{ 1311 struct process_block_struct pb; 1312 ext2_ino_t ino, new_inode; 1313 struct ext2_inode *inode = NULL; 1314 ext2_inode_scan scan = NULL; 1315 errcode_t retval; 1316 char *block_buf = 0; 1317 ext2_ino_t start_to_move; 1318 blk64_t orig_size; 1319 blk64_t new_block; 1320 int inode_size; 1321 1322 if ((rfs->old_fs->group_desc_count <= 1323 rfs->new_fs->group_desc_count) && 1324 !rfs->bmap) 1325 return 0; 1326 1327 /* 1328 * Save the original size of the old filesystem, and 1329 * temporarily set the size to be the new size if the new size 1330 * is larger. We need to do this to avoid catching an error 1331 * by the block iterator routines 1332 */ 1333 orig_size = ext2fs_blocks_count(rfs->old_fs->super); 1334 if (orig_size < ext2fs_blocks_count(rfs->new_fs->super)) 1335 ext2fs_blocks_count_set(rfs->old_fs->super, 1336 ext2fs_blocks_count(rfs->new_fs->super)); 1337 1338 retval = ext2fs_open_inode_scan(rfs->old_fs, 0, &scan); 1339 if (retval) goto errout; 1340 1341 retval = ext2fs_init_dblist(rfs->old_fs, 0); 1342 if (retval) goto errout; 1343 retval = ext2fs_get_array(rfs->old_fs->blocksize, 3, &block_buf); 1344 if (retval) goto errout; 1345 1346 start_to_move = (rfs->new_fs->group_desc_count * 1347 rfs->new_fs->super->s_inodes_per_group); 1348 1349 if (rfs->progress) { 1350 retval = (rfs->progress)(rfs, E2_RSZ_INODE_SCAN_PASS, 1351 0, rfs->old_fs->group_desc_count); 1352 if (retval) 1353 goto errout; 1354 } 1355 ext2fs_set_inode_callback(scan, progress_callback, (void *) rfs); 1356 pb.rfs = rfs; 1357 pb.inode = inode; 1358 pb.error = 0; 1359 new_inode = EXT2_FIRST_INODE(rfs->new_fs->super); 1360 inode_size = EXT2_INODE_SIZE(rfs->new_fs->super); 1361 inode = malloc(inode_size); 1362 if (!inode) { 1363 retval = ENOMEM; 1364 goto errout; 1365 } 1366 /* 1367 * First, copy all of the inodes that need to be moved 1368 * elsewhere in the inode table 1369 */ 1370 while (1) { 1371 retval = ext2fs_get_next_inode_full(scan, &ino, inode, inode_size); 1372 if (retval) goto errout; 1373 if (!ino) 1374 break; 1375 1376 if (inode->i_links_count == 0 && ino != EXT2_RESIZE_INO) 1377 continue; /* inode not in use */ 1378 1379 pb.is_dir = LINUX_S_ISDIR(inode->i_mode); 1380 pb.changed = 0; 1381 1382 if (ext2fs_file_acl_block(rfs->old_fs, inode) && rfs->bmap) { 1383 new_block = ext2fs_extent_translate(rfs->bmap, 1384 ext2fs_file_acl_block(rfs->old_fs, inode)); 1385 if (new_block) { 1386 ext2fs_file_acl_block_set(rfs->old_fs, inode, 1387 new_block); 1388 retval = ext2fs_write_inode_full(rfs->old_fs, 1389 ino, inode, inode_size); 1390 if (retval) goto errout; 1391 } 1392 } 1393 1394 if (ext2fs_inode_has_valid_blocks2(rfs->old_fs, inode) && 1395 (rfs->bmap || pb.is_dir)) { 1396 pb.ino = ino; 1397 retval = ext2fs_block_iterate3(rfs->old_fs, 1398 ino, 0, block_buf, 1399 process_block, &pb); 1400 if (retval) 1401 goto errout; 1402 if (pb.error) { 1403 retval = pb.error; 1404 goto errout; 1405 } 1406 } 1407 1408 if (ino <= start_to_move) 1409 continue; /* Don't need to move it. */ 1410 1411 /* 1412 * Find a new inode 1413 */ 1414 retval = ext2fs_new_inode(rfs->new_fs, 0, 0, 0, &new_inode); 1415 if (retval) 1416 goto errout; 1417 1418 ext2fs_inode_alloc_stats2(rfs->new_fs, new_inode, +1, 1419 pb.is_dir); 1420 if (pb.changed) { 1421 /* Get the new version of the inode */ 1422 retval = ext2fs_read_inode_full(rfs->old_fs, ino, 1423 inode, inode_size); 1424 if (retval) goto errout; 1425 } 1426 inode->i_ctime = time(0); 1427 retval = ext2fs_write_inode_full(rfs->old_fs, new_inode, 1428 inode, inode_size); 1429 if (retval) goto errout; 1430 1431#ifdef RESIZE2FS_DEBUG 1432 if (rfs->flags & RESIZE_DEBUG_INODEMAP) 1433 printf("Inode moved %u->%u\n", ino, new_inode); 1434#endif 1435 if (!rfs->imap) { 1436 retval = ext2fs_create_extent_table(&rfs->imap, 0); 1437 if (retval) 1438 goto errout; 1439 } 1440 ext2fs_add_extent_entry(rfs->imap, ino, new_inode); 1441 } 1442 io_channel_flush(rfs->old_fs->io); 1443 1444errout: 1445 ext2fs_blocks_count_set(rfs->old_fs->super, orig_size); 1446 if (rfs->bmap) { 1447 ext2fs_free_extent_table(rfs->bmap); 1448 rfs->bmap = 0; 1449 } 1450 if (scan) 1451 ext2fs_close_inode_scan(scan); 1452 if (block_buf) 1453 ext2fs_free_mem(&block_buf); 1454 free(inode); 1455 return retval; 1456} 1457 1458/* -------------------------------------------------------------------- 1459 * 1460 * Resize processing, phase 4. 1461 * 1462 * -------------------------------------------------------------------- 1463 */ 1464 1465struct istruct { 1466 ext2_resize_t rfs; 1467 errcode_t err; 1468 unsigned int max_dirs; 1469 unsigned int num; 1470}; 1471 1472static int check_and_change_inodes(ext2_ino_t dir, 1473 int entry EXT2FS_ATTR((unused)), 1474 struct ext2_dir_entry *dirent, int offset, 1475 int blocksize EXT2FS_ATTR((unused)), 1476 char *buf EXT2FS_ATTR((unused)), 1477 void *priv_data) 1478{ 1479 struct istruct *is = (struct istruct *) priv_data; 1480 struct ext2_inode inode; 1481 ext2_ino_t new_inode; 1482 errcode_t retval; 1483 1484 if (is->rfs->progress && offset == 0) { 1485 io_channel_flush(is->rfs->old_fs->io); 1486 is->err = (is->rfs->progress)(is->rfs, 1487 E2_RSZ_INODE_REF_UPD_PASS, 1488 ++is->num, is->max_dirs); 1489 if (is->err) 1490 return DIRENT_ABORT; 1491 } 1492 1493 if (!dirent->inode) 1494 return 0; 1495 1496 new_inode = ext2fs_extent_translate(is->rfs->imap, dirent->inode); 1497 1498 if (!new_inode) 1499 return 0; 1500#ifdef RESIZE2FS_DEBUG 1501 if (is->rfs->flags & RESIZE_DEBUG_INODEMAP) 1502 printf("Inode translate (dir=%u, name=%.*s, %u->%u)\n", 1503 dir, dirent->name_len&0xFF, dirent->name, 1504 dirent->inode, new_inode); 1505#endif 1506 1507 dirent->inode = new_inode; 1508 1509 /* Update the directory mtime and ctime */ 1510 retval = ext2fs_read_inode(is->rfs->old_fs, dir, &inode); 1511 if (retval == 0) { 1512 inode.i_mtime = inode.i_ctime = time(0); 1513 is->err = ext2fs_write_inode(is->rfs->old_fs, dir, &inode); 1514 if (is->err) 1515 return DIRENT_ABORT; 1516 } 1517 1518 return DIRENT_CHANGED; 1519} 1520 1521static errcode_t inode_ref_fix(ext2_resize_t rfs) 1522{ 1523 errcode_t retval; 1524 struct istruct is; 1525 1526 if (!rfs->imap) 1527 return 0; 1528 1529 /* 1530 * Now, we iterate over all of the directories to update the 1531 * inode references 1532 */ 1533 is.num = 0; 1534 is.max_dirs = ext2fs_dblist_count2(rfs->old_fs->dblist); 1535 is.rfs = rfs; 1536 is.err = 0; 1537 1538 if (rfs->progress) { 1539 retval = (rfs->progress)(rfs, E2_RSZ_INODE_REF_UPD_PASS, 1540 0, is.max_dirs); 1541 if (retval) 1542 goto errout; 1543 } 1544 1545 retval = ext2fs_dblist_dir_iterate(rfs->old_fs->dblist, 1546 DIRENT_FLAG_INCLUDE_EMPTY, 0, 1547 check_and_change_inodes, &is); 1548 if (retval) 1549 goto errout; 1550 if (is.err) { 1551 retval = is.err; 1552 goto errout; 1553 } 1554 1555 if (rfs->progress && (is.num < is.max_dirs)) 1556 (rfs->progress)(rfs, E2_RSZ_INODE_REF_UPD_PASS, 1557 is.max_dirs, is.max_dirs); 1558 1559errout: 1560 ext2fs_free_extent_table(rfs->imap); 1561 rfs->imap = 0; 1562 return retval; 1563} 1564 1565 1566/* -------------------------------------------------------------------- 1567 * 1568 * Resize processing, phase 5. 1569 * 1570 * In this phase we actually move the inode table around, and then 1571 * update the summary statistics. This is scary, since aborting here 1572 * will potentially scramble the filesystem. (We are moving the 1573 * inode tables around in place, and so the potential for lost data, 1574 * or at the very least scrambling the mapping between filenames and 1575 * inode numbers is very high in case of a power failure here.) 1576 * -------------------------------------------------------------------- 1577 */ 1578 1579 1580/* 1581 * A very scary routine --- this one moves the inode table around!!! 1582 * 1583 * After this you have to use the rfs->new_fs file handle to read and 1584 * write inodes. 1585 */ 1586static errcode_t move_itables(ext2_resize_t rfs) 1587{ 1588 int n, num, size; 1589 long long diff; 1590 dgrp_t i, max_groups; 1591 ext2_filsys fs = rfs->new_fs; 1592 char *cp; 1593 blk64_t old_blk, new_blk, blk; 1594 errcode_t retval; 1595 int j, to_move, moved; 1596 1597 max_groups = fs->group_desc_count; 1598 if (max_groups > rfs->old_fs->group_desc_count) 1599 max_groups = rfs->old_fs->group_desc_count; 1600 1601 size = fs->blocksize * fs->inode_blocks_per_group; 1602 if (!rfs->itable_buf) { 1603 retval = ext2fs_get_mem(size, &rfs->itable_buf); 1604 if (retval) 1605 return retval; 1606 } 1607 1608 /* 1609 * Figure out how many inode tables we need to move 1610 */ 1611 to_move = moved = 0; 1612 for (i=0; i < max_groups; i++) 1613 if (ext2fs_inode_table_loc(rfs->old_fs, i) != 1614 ext2fs_inode_table_loc(fs, i)) 1615 to_move++; 1616 1617 if (to_move == 0) 1618 return 0; 1619 1620 if (rfs->progress) { 1621 retval = rfs->progress(rfs, E2_RSZ_MOVE_ITABLE_PASS, 1622 0, to_move); 1623 if (retval) 1624 goto errout; 1625 } 1626 1627 rfs->old_fs->flags |= EXT2_FLAG_MASTER_SB_ONLY; 1628 1629 for (i=0; i < max_groups; i++) { 1630 old_blk = ext2fs_inode_table_loc(rfs->old_fs, i); 1631 new_blk = ext2fs_inode_table_loc(fs, i); 1632 diff = new_blk - old_blk; 1633 1634#ifdef RESIZE2FS_DEBUG 1635 if (rfs->flags & RESIZE_DEBUG_ITABLEMOVE) 1636 printf("Itable move group %d block %llu->%llu (diff %lld)\n", 1637 i, old_blk, new_blk, diff); 1638#endif 1639 1640 if (!diff) 1641 continue; 1642 1643 retval = io_channel_read_blk64(fs->io, old_blk, 1644 fs->inode_blocks_per_group, 1645 rfs->itable_buf); 1646 if (retval) 1647 goto errout; 1648 /* 1649 * The end of the inode table segment often contains 1650 * all zeros, and we're often only moving the inode 1651 * table down a block or two. If so, we can optimize 1652 * things by not rewriting blocks that we know to be zero 1653 * already. 1654 */ 1655 for (cp = rfs->itable_buf+size-1, n=0; n < size; n++, cp--) 1656 if (*cp) 1657 break; 1658 n = n >> EXT2_BLOCK_SIZE_BITS(fs->super); 1659#ifdef RESIZE2FS_DEBUG 1660 if (rfs->flags & RESIZE_DEBUG_ITABLEMOVE) 1661 printf("%d blocks of zeros...\n", n); 1662#endif 1663 num = fs->inode_blocks_per_group; 1664 if (n > diff) 1665 num -= n; 1666 1667 retval = io_channel_write_blk64(fs->io, new_blk, 1668 num, rfs->itable_buf); 1669 if (retval) { 1670 io_channel_write_blk64(fs->io, old_blk, 1671 num, rfs->itable_buf); 1672 goto errout; 1673 } 1674 if (n > diff) { 1675 retval = io_channel_write_blk64(fs->io, 1676 old_blk + fs->inode_blocks_per_group, 1677 diff, (rfs->itable_buf + 1678 (fs->inode_blocks_per_group - diff) * 1679 fs->blocksize)); 1680 if (retval) 1681 goto errout; 1682 } 1683 1684 for (blk = ext2fs_inode_table_loc(rfs->old_fs, i), j=0; 1685 j < fs->inode_blocks_per_group ; j++, blk++) 1686 ext2fs_block_alloc_stats2(fs, blk, -1); 1687 1688 ext2fs_inode_table_loc_set(rfs->old_fs, i, new_blk); 1689 ext2fs_group_desc_csum_set(rfs->old_fs, i); 1690 ext2fs_mark_super_dirty(rfs->old_fs); 1691 ext2fs_flush(rfs->old_fs); 1692 1693 if (rfs->progress) { 1694 retval = rfs->progress(rfs, E2_RSZ_MOVE_ITABLE_PASS, 1695 ++moved, to_move); 1696 if (retval) 1697 goto errout; 1698 } 1699 } 1700 mark_table_blocks(fs, fs->block_map); 1701 ext2fs_flush(fs); 1702#ifdef RESIZE2FS_DEBUG 1703 if (rfs->flags & RESIZE_DEBUG_ITABLEMOVE) 1704 printf("Inode table move finished.\n"); 1705#endif 1706 return 0; 1707 1708errout: 1709 return retval; 1710} 1711 1712/* 1713 * Fix the resize inode 1714 */ 1715static errcode_t fix_resize_inode(ext2_filsys fs) 1716{ 1717 struct ext2_inode inode; 1718 errcode_t retval; 1719 char *block_buf = NULL; 1720 1721 if (!(fs->super->s_feature_compat & 1722 EXT2_FEATURE_COMPAT_RESIZE_INODE)) 1723 return 0; 1724 1725 retval = ext2fs_get_mem(fs->blocksize, &block_buf); 1726 if (retval) goto errout; 1727 1728 retval = ext2fs_read_inode(fs, EXT2_RESIZE_INO, &inode); 1729 if (retval) goto errout; 1730 1731 ext2fs_iblk_set(fs, &inode, 1); 1732 1733 retval = ext2fs_write_inode(fs, EXT2_RESIZE_INO, &inode); 1734 if (retval) goto errout; 1735 1736 if (!inode.i_block[EXT2_DIND_BLOCK]) { 1737 /* 1738 * Avoid zeroing out block #0; that's rude. This 1739 * should never happen anyway since the filesystem 1740 * should be fsck'ed and we assume it is consistent. 1741 */ 1742 fprintf(stderr, 1743 _("Should never happen: resize inode corrupt!\n")); 1744 exit(1); 1745 } 1746 1747 memset(block_buf, 0, fs->blocksize); 1748 1749 retval = io_channel_write_blk64(fs->io, inode.i_block[EXT2_DIND_BLOCK], 1750 1, block_buf); 1751 if (retval) goto errout; 1752 1753 retval = ext2fs_create_resize_inode(fs); 1754 if (retval) 1755 goto errout; 1756 1757errout: 1758 if (block_buf) 1759 ext2fs_free_mem(&block_buf); 1760 return retval; 1761} 1762 1763/* 1764 * Finally, recalculate the summary information 1765 */ 1766static errcode_t ext2fs_calculate_summary_stats(ext2_filsys fs) 1767{ 1768 blk64_t blk; 1769 ext2_ino_t ino; 1770 unsigned int group = 0; 1771 unsigned int count = 0; 1772 int total_free = 0; 1773 int group_free = 0; 1774 int uninit = 0; 1775 blk64_t super_blk, old_desc_blk, new_desc_blk; 1776 int old_desc_blocks; 1777 1778 /* 1779 * First calculate the block statistics 1780 */ 1781 uninit = ext2fs_bg_flags_test(fs, group, EXT2_BG_BLOCK_UNINIT); 1782 ext2fs_super_and_bgd_loc2(fs, group, &super_blk, &old_desc_blk, 1783 &new_desc_blk, 0); 1784 if (fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_META_BG) 1785 old_desc_blocks = fs->super->s_first_meta_bg; 1786 else 1787 old_desc_blocks = fs->desc_blocks + 1788 fs->super->s_reserved_gdt_blocks; 1789 for (blk = fs->super->s_first_data_block; 1790 blk < ext2fs_blocks_count(fs->super); blk++) { 1791 if ((uninit && 1792 !((blk == super_blk) || 1793 ((old_desc_blk && old_desc_blocks && 1794 (blk >= old_desc_blk) && 1795 (blk < old_desc_blk + old_desc_blocks))) || 1796 ((new_desc_blk && (blk == new_desc_blk))) || 1797 (blk == ext2fs_block_bitmap_loc(fs, group)) || 1798 (blk == ext2fs_inode_bitmap_loc(fs, group)) || 1799 ((blk >= ext2fs_inode_table_loc(fs, group) && 1800 (blk < ext2fs_inode_table_loc(fs, group) 1801 + fs->inode_blocks_per_group))))) || 1802 (!ext2fs_fast_test_block_bitmap2(fs->block_map, blk))) { 1803 group_free++; 1804 total_free++; 1805 } 1806 count++; 1807 if ((count == fs->super->s_blocks_per_group) || 1808 (blk == ext2fs_blocks_count(fs->super)-1)) { 1809 ext2fs_bg_free_blocks_count_set(fs, group, group_free); 1810 ext2fs_group_desc_csum_set(fs, group); 1811 group++; 1812 if (group >= fs->group_desc_count) 1813 break; 1814 count = 0; 1815 group_free = 0; 1816 uninit = ext2fs_bg_flags_test(fs, group, EXT2_BG_BLOCK_UNINIT); 1817 ext2fs_super_and_bgd_loc2(fs, group, &super_blk, 1818 &old_desc_blk, 1819 &new_desc_blk, 0); 1820 if (fs->super->s_feature_incompat & 1821 EXT2_FEATURE_INCOMPAT_META_BG) 1822 old_desc_blocks = fs->super->s_first_meta_bg; 1823 else 1824 old_desc_blocks = fs->desc_blocks + 1825 fs->super->s_reserved_gdt_blocks; 1826 } 1827 } 1828 ext2fs_free_blocks_count_set(fs->super, total_free); 1829 1830 /* 1831 * Next, calculate the inode statistics 1832 */ 1833 group_free = 0; 1834 total_free = 0; 1835 count = 0; 1836 group = 0; 1837 1838 /* Protect loop from wrap-around if s_inodes_count maxed */ 1839 uninit = ext2fs_bg_flags_test(fs, group, EXT2_BG_INODE_UNINIT); 1840 for (ino = 1; ino <= fs->super->s_inodes_count && ino > 0; ino++) { 1841 if (uninit || 1842 !ext2fs_fast_test_inode_bitmap2(fs->inode_map, ino)) { 1843 group_free++; 1844 total_free++; 1845 } 1846 count++; 1847 if ((count == fs->super->s_inodes_per_group) || 1848 (ino == fs->super->s_inodes_count)) { 1849 ext2fs_bg_free_inodes_count_set(fs, group, group_free); 1850 ext2fs_group_desc_csum_set(fs, group); 1851 group++; 1852 if (group >= fs->group_desc_count) 1853 break; 1854 count = 0; 1855 group_free = 0; 1856 uninit = ext2fs_bg_flags_test(fs, group, EXT2_BG_INODE_UNINIT); 1857 } 1858 } 1859 fs->super->s_free_inodes_count = total_free; 1860 ext2fs_mark_super_dirty(fs); 1861 return 0; 1862} 1863 1864/* 1865 * Journal may have been relocated; update the backup journal blocks 1866 * in the superblock. 1867 */ 1868static errcode_t fix_sb_journal_backup(ext2_filsys fs) 1869{ 1870 errcode_t retval; 1871 struct ext2_inode inode; 1872 1873 if (!(fs->super->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL)) 1874 return 0; 1875 1876 /* External journal? Nothing to do. */ 1877 if (fs->super->s_journal_dev && !fs->super->s_journal_inum) 1878 return 0; 1879 1880 retval = ext2fs_read_inode(fs, fs->super->s_journal_inum, &inode); 1881 if (retval) 1882 return retval; 1883 memcpy(fs->super->s_jnl_blocks, inode.i_block, EXT2_N_BLOCKS*4); 1884 fs->super->s_jnl_blocks[15] = inode.i_size_high; 1885 fs->super->s_jnl_blocks[16] = inode.i_size; 1886 fs->super->s_jnl_backup_type = EXT3_JNL_BACKUP_BLOCKS; 1887 ext2fs_mark_super_dirty(fs); 1888 return 0; 1889} 1890 1891static int calc_group_overhead(ext2_filsys fs, blk64_t grp, 1892 int old_desc_blocks) 1893{ 1894 blk64_t super_blk, old_desc_blk, new_desc_blk; 1895 int overhead; 1896 1897 /* inode table blocks plus allocation bitmaps */ 1898 overhead = fs->inode_blocks_per_group + 2; 1899 1900 ext2fs_super_and_bgd_loc2(fs, grp, &super_blk, 1901 &old_desc_blk, &new_desc_blk, 0); 1902 if ((grp == 0) || super_blk) 1903 overhead++; 1904 if (old_desc_blk) 1905 overhead += old_desc_blocks; 1906 else if (new_desc_blk) 1907 overhead++; 1908 return overhead; 1909} 1910 1911 1912/* 1913 * calcluate the minimum number of blocks the given fs can be resized to 1914 */ 1915blk64_t calculate_minimum_resize_size(ext2_filsys fs) 1916{ 1917 ext2_ino_t inode_count; 1918 blk64_t blks_needed, groups, data_blocks; 1919 blk64_t grp, data_needed, last_start; 1920 blk64_t overhead = 0; 1921 int old_desc_blocks; 1922 int extra_groups = 0; 1923 int flexbg_size = 1 << fs->super->s_log_groups_per_flex; 1924 1925 /* 1926 * first figure out how many group descriptors we need to 1927 * handle the number of inodes we have 1928 */ 1929 inode_count = fs->super->s_inodes_count - 1930 fs->super->s_free_inodes_count; 1931 blks_needed = ext2fs_div_ceil(inode_count, 1932 fs->super->s_inodes_per_group) * 1933 EXT2_BLOCKS_PER_GROUP(fs->super); 1934 groups = ext2fs_div64_ceil(blks_needed, 1935 EXT2_BLOCKS_PER_GROUP(fs->super)); 1936 1937 /* 1938 * number of old-style block group descriptor blocks 1939 */ 1940 if (fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_META_BG) 1941 old_desc_blocks = fs->super->s_first_meta_bg; 1942 else 1943 old_desc_blocks = fs->desc_blocks + 1944 fs->super->s_reserved_gdt_blocks; 1945 1946 /* calculate how many blocks are needed for data */ 1947 data_needed = ext2fs_blocks_count(fs->super) - 1948 ext2fs_free_blocks_count(fs->super); 1949 1950 for (grp = 0; grp < fs->group_desc_count; grp++) 1951 data_needed -= calc_group_overhead(fs, grp, old_desc_blocks); 1952 1953 /* 1954 * For ext4 we need to allow for up to a flex_bg worth of 1955 * inode tables of slack space so the resize operation can be 1956 * guaranteed to finish. 1957 */ 1958 if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_FLEX_BG) { 1959 extra_groups = flexbg_size - (groups & (flexbg_size - 1)); 1960 data_needed += fs->inode_blocks_per_group * extra_groups; 1961 extra_groups = groups % flexbg_size; 1962 } 1963 1964 /* 1965 * figure out how many data blocks we have given the number of groups 1966 * we need for our inodes 1967 */ 1968 data_blocks = groups * EXT2_BLOCKS_PER_GROUP(fs->super); 1969 last_start = 0; 1970 for (grp = 0; grp < groups; grp++) { 1971 overhead = calc_group_overhead(fs, grp, old_desc_blocks); 1972 1973 /* 1974 * we want to keep track of how much data we can store in 1975 * the groups leading up to the last group so we can determine 1976 * how big the last group needs to be 1977 */ 1978 if (grp != (groups - 1)) 1979 last_start += EXT2_BLOCKS_PER_GROUP(fs->super) - 1980 overhead; 1981 1982 data_blocks -= overhead; 1983 } 1984 1985 /* 1986 * if we need more group descriptors in order to accomodate our data 1987 * then we need to add them here 1988 */ 1989 while (data_needed > data_blocks) { 1990 blk64_t remainder = data_needed - data_blocks; 1991 blk64_t extra_grps; 1992 1993 /* figure out how many more groups we need for the data */ 1994 extra_grps = ext2fs_div64_ceil(remainder, 1995 EXT2_BLOCKS_PER_GROUP(fs->super)); 1996 1997 data_blocks += extra_grps * EXT2_BLOCKS_PER_GROUP(fs->super); 1998 1999 /* ok we have to account for the last group */ 2000 overhead = calc_group_overhead(fs, groups-1, old_desc_blocks); 2001 last_start += EXT2_BLOCKS_PER_GROUP(fs->super) - overhead; 2002 2003 for (grp = groups; grp < groups+extra_grps; grp++) { 2004 overhead = calc_group_overhead(fs, grp, 2005 old_desc_blocks); 2006 2007 /* 2008 * again, we need to see how much data we cram into 2009 * all of the groups leading up to the last group 2010 */ 2011 if (grp != (groups + extra_grps - 1)) 2012 last_start += EXT2_BLOCKS_PER_GROUP(fs->super) 2013 - overhead; 2014 2015 data_blocks -= overhead; 2016 } 2017 2018 groups += extra_grps; 2019 extra_groups += extra_grps; 2020 if (fs->super->s_feature_incompat 2021 & EXT4_FEATURE_INCOMPAT_FLEX_BG 2022 && extra_groups > flexbg_size) { 2023 /* 2024 * For ext4 we need to allow for up to a flex_bg worth 2025 * of inode tables of slack space so the resize 2026 * operation can be guaranteed to finish. 2027 */ 2028 extra_groups = flexbg_size - 2029 (groups & (flexbg_size - 1)); 2030 data_needed += (fs->inode_blocks_per_group * 2031 extra_groups); 2032 extra_groups = groups % flexbg_size; 2033 } 2034 } 2035 2036 /* now for the fun voodoo */ 2037 overhead = calc_group_overhead(fs, groups-1, old_desc_blocks); 2038 2039 /* 2040 * if this is the case then the last group is going to have data in it 2041 * so we need to adjust the size of the last group accordingly 2042 */ 2043 if (last_start < data_needed) { 2044 blk64_t remainder = data_needed - last_start; 2045 2046 /* 2047 * 50 is a magic number that mkfs/resize uses to see if its 2048 * even worth making/resizing the fs. basically you need to 2049 * have at least 50 blocks in addition to the blocks needed 2050 * for the metadata in the last group 2051 */ 2052 if (remainder > 50) 2053 overhead += remainder; 2054 else 2055 overhead += 50; 2056 } else 2057 overhead += 50; 2058 2059 overhead += fs->super->s_first_data_block; 2060 2061 /* 2062 * since our last group doesn't have to be BLOCKS_PER_GROUP large, we 2063 * only do groups-1, and then add the number of blocks needed to 2064 * handle the group descriptor metadata+data that we need 2065 */ 2066 blks_needed = (groups-1) * EXT2_BLOCKS_PER_GROUP(fs->super); 2067 blks_needed += overhead; 2068 2069 /* 2070 * If at this point we've already added up more "needed" than 2071 * the current size, just return current size as minimum. 2072 */ 2073 if (blks_needed >= ext2fs_blocks_count(fs->super)) 2074 return ext2fs_blocks_count(fs->super); 2075 /* 2076 * We need to reserve a few extra blocks if extents are 2077 * enabled, in case we need to grow the extent tree. The more 2078 * we shrink the file system, the more space we need. 2079 */ 2080 if (fs->super->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS) 2081 blks_needed += (ext2fs_blocks_count(fs->super) - 2082 blks_needed)/500; 2083 2084 return blks_needed; 2085} 2086