diff options
Diffstat (limited to 'resize/resize2fs.c')
| -rw-r--r-- | resize/resize2fs.c | 3235 |
1 files changed, 3235 insertions, 0 deletions
diff --git a/resize/resize2fs.c b/resize/resize2fs.c new file mode 100644 index 0000000..5eeb7d4 --- /dev/null +++ b/resize/resize2fs.c @@ -0,0 +1,3235 @@ +/* + * resize2fs.c --- ext2 main routine + * + * Copyright (C) 1997, 1998 by Theodore Ts'o and + * PowerQuest, Inc. + * + * Copyright (C) 1999, 2000 by Theodore Ts'o + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + */ + +/* + * Resizing a filesystem consists of the following phases: + * + * 1. Adjust superblock and write out new parts of the inode + * table + * 2. Determine blocks which need to be relocated, and copy the + * contents of blocks from their old locations to the new ones. + * 3. Scan the inode table, doing the following: + * a. If blocks have been moved, update the block + * pointers in the inodes and indirect blocks to + * point at the new block locations. + * b. If parts of the inode table need to be evacuated, + * copy inodes from their old locations to their + * new ones. + * c. If (b) needs to be done, note which blocks contain + * directory information, since we will need to + * update the directory information. + * 4. Update the directory blocks with the new inode locations. + * 5. Move the inode tables, if necessary. + */ + +#include "config.h" +#include "resize2fs.h" +#include <time.h> + +#ifdef __linux__ /* Kludge for debugging */ +#define RESIZE2FS_DEBUG +#endif + +static void fix_uninit_block_bitmaps(ext2_filsys fs); +static errcode_t adjust_superblock(ext2_resize_t rfs, blk64_t new_size); +static errcode_t blocks_to_move(ext2_resize_t rfs); +static errcode_t block_mover(ext2_resize_t rfs); +static errcode_t inode_scan_and_fix(ext2_resize_t rfs); +static errcode_t inode_ref_fix(ext2_resize_t rfs); +static errcode_t move_itables(ext2_resize_t rfs); +static errcode_t fix_resize_inode(ext2_filsys fs); +static errcode_t resize2fs_calculate_summary_stats(ext2_filsys fs); +static errcode_t fix_sb_journal_backup(ext2_filsys fs); +static errcode_t mark_table_blocks(ext2_filsys fs, + ext2fs_block_bitmap bmap); +static errcode_t clear_sparse_super2_last_group(ext2_resize_t rfs); +static errcode_t reserve_sparse_super2_last_group(ext2_resize_t rfs, + ext2fs_block_bitmap meta_bmap); +static errcode_t resize_group_descriptors(ext2_resize_t rfs, blk64_t new_size); +static errcode_t move_bg_metadata(ext2_resize_t rfs); +static errcode_t zero_high_bits_in_inodes(ext2_resize_t rfs); + +/* + * Some helper functions to check if a block is in a metadata area + */ +static inline int is_block_bm(ext2_filsys fs, unsigned int grp, blk64_t blk) +{ + return blk == ext2fs_block_bitmap_loc(fs, grp); +} + +static inline int is_inode_bm(ext2_filsys fs, unsigned int grp, blk64_t blk) +{ + return blk == ext2fs_inode_bitmap_loc(fs, grp); +} + +static int is_inode_tb(ext2_filsys fs, unsigned int grp, blk64_t blk) +{ + return blk >= ext2fs_inode_table_loc(fs, grp) && + blk < (ext2fs_inode_table_loc(fs, grp) + + fs->inode_blocks_per_group); +} + +/* Some bigalloc helper macros which are more succinct... */ +#define B2C(x) EXT2FS_B2C(fs, (x)) +#define C2B(x) EXT2FS_C2B(fs, (x)) +#define EQ_CLSTR(x, y) (B2C(x) == B2C(y)) +#define LE_CLSTR(x, y) (B2C(x) <= B2C(y)) +#define LT_CLSTR(x, y) (B2C(x) < B2C(y)) +#define GE_CLSTR(x, y) (B2C(x) >= B2C(y)) +#define GT_CLSTR(x, y) (B2C(x) > B2C(y)) + +static int lazy_itable_init; + +/* + * This is the top-level routine which does the dirty deed.... + */ +errcode_t resize_fs(ext2_filsys fs, blk64_t *new_size, int flags, + errcode_t (*progress)(ext2_resize_t rfs, int pass, + unsigned long cur, + unsigned long max_val)) +{ + ext2_resize_t rfs; + errcode_t retval; + struct resource_track rtrack, overall_track; + + /* + * Create the data structure + */ + retval = ext2fs_get_mem(sizeof(struct ext2_resize_struct), &rfs); + if (retval) + return retval; + + memset(rfs, 0, sizeof(struct ext2_resize_struct)); + fs->priv_data = rfs; + rfs->old_fs = fs; + rfs->flags = flags; + rfs->itable_buf = 0; + rfs->progress = progress; + + init_resource_track(&overall_track, "overall resize2fs", fs->io); + init_resource_track(&rtrack, "read_bitmaps", fs->io); + retval = ext2fs_read_bitmaps(fs); + if (retval) + goto errout; + print_resource_track(rfs, &rtrack, fs->io); + + fs->super->s_state |= EXT2_ERROR_FS; + ext2fs_mark_super_dirty(fs); + ext2fs_flush(fs); + + init_resource_track(&rtrack, "fix_uninit_block_bitmaps 1", fs->io); + fix_uninit_block_bitmaps(fs); + print_resource_track(rfs, &rtrack, fs->io); + retval = ext2fs_dup_handle(fs, &rfs->new_fs); + if (retval) + goto errout; + + init_resource_track(&rtrack, "resize_group_descriptors", fs->io); + retval = resize_group_descriptors(rfs, *new_size); + if (retval) + goto errout; + print_resource_track(rfs, &rtrack, fs->io); + + init_resource_track(&rtrack, "move_bg_metadata", fs->io); + retval = move_bg_metadata(rfs); + if (retval) + goto errout; + print_resource_track(rfs, &rtrack, fs->io); + + init_resource_track(&rtrack, "zero_high_bits_in_metadata", fs->io); + retval = zero_high_bits_in_inodes(rfs); + if (retval) + goto errout; + print_resource_track(rfs, &rtrack, fs->io); + + init_resource_track(&rtrack, "adjust_superblock", fs->io); + retval = adjust_superblock(rfs, *new_size); + if (retval) + goto errout; + print_resource_track(rfs, &rtrack, fs->io); + + init_resource_track(&rtrack, "fix_uninit_block_bitmaps 2", fs->io); + fix_uninit_block_bitmaps(rfs->new_fs); + print_resource_track(rfs, &rtrack, fs->io); + /* Clear the block bitmap uninit flag for the last block group */ + ext2fs_bg_flags_clear(rfs->new_fs, rfs->new_fs->group_desc_count - 1, + EXT2_BG_BLOCK_UNINIT); + + *new_size = ext2fs_blocks_count(rfs->new_fs->super); + + init_resource_track(&rtrack, "blocks_to_move", fs->io); + retval = blocks_to_move(rfs); + if (retval) + goto errout; + print_resource_track(rfs, &rtrack, fs->io); + +#ifdef RESIZE2FS_DEBUG + if (rfs->flags & RESIZE_DEBUG_BMOVE) + printf("Number of free blocks: %llu/%llu, Needed: %llu\n", + (unsigned long long) ext2fs_free_blocks_count(rfs->old_fs->super), + (unsigned long long) ext2fs_free_blocks_count(rfs->new_fs->super), + (unsigned long long) rfs->needed_blocks); +#endif + + init_resource_track(&rtrack, "block_mover", fs->io); + retval = block_mover(rfs); + if (retval) + goto errout; + print_resource_track(rfs, &rtrack, fs->io); + + init_resource_track(&rtrack, "inode_scan_and_fix", fs->io); + retval = inode_scan_and_fix(rfs); + if (retval) + goto errout; + print_resource_track(rfs, &rtrack, fs->io); + + init_resource_track(&rtrack, "inode_ref_fix", fs->io); + retval = inode_ref_fix(rfs); + if (retval) + goto errout; + print_resource_track(rfs, &rtrack, fs->io); + + init_resource_track(&rtrack, "move_itables", fs->io); + retval = move_itables(rfs); + if (retval) + goto errout; + print_resource_track(rfs, &rtrack, fs->io); + + retval = clear_sparse_super2_last_group(rfs); + if (retval) + goto errout; + + init_resource_track(&rtrack, "calculate_summary_stats", fs->io); + retval = resize2fs_calculate_summary_stats(rfs->new_fs); + if (retval) + goto errout; + print_resource_track(rfs, &rtrack, fs->io); + + init_resource_track(&rtrack, "fix_resize_inode", fs->io); + retval = fix_resize_inode(rfs->new_fs); + if (retval) + goto errout; + print_resource_track(rfs, &rtrack, fs->io); + + init_resource_track(&rtrack, "fix_sb_journal_backup", fs->io); + retval = fix_sb_journal_backup(rfs->new_fs); + if (retval) + goto errout; + print_resource_track(rfs, &rtrack, fs->io); + + retval = ext2fs_set_gdt_csum(rfs->new_fs); + if (retval) + goto errout; + + rfs->new_fs->super->s_state &= ~EXT2_ERROR_FS; + rfs->new_fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; + + print_resource_track(rfs, &overall_track, fs->io); + retval = ext2fs_close_free(&rfs->new_fs); + if (retval) + goto errout; + + rfs->flags = flags; + + ext2fs_free(rfs->old_fs); + rfs->old_fs = NULL; + if (rfs->itable_buf) + ext2fs_free_mem(&rfs->itable_buf); + if (rfs->reserve_blocks) + ext2fs_free_block_bitmap(rfs->reserve_blocks); + if (rfs->move_blocks) + ext2fs_free_block_bitmap(rfs->move_blocks); + ext2fs_free_mem(&rfs); + + return 0; + +errout: + if (rfs->new_fs) { + ext2fs_free(rfs->new_fs); + rfs->new_fs = NULL; + } + if (rfs->itable_buf) + ext2fs_free_mem(&rfs->itable_buf); + ext2fs_free_mem(&rfs); + return retval; +} + +/* Keep the size of the group descriptor region constant */ +static void adjust_reserved_gdt_blocks(ext2_filsys old_fs, ext2_filsys fs) +{ + if (ext2fs_has_feature_resize_inode(fs->super) && + (old_fs->desc_blocks != fs->desc_blocks)) { + int new; + + new = ((int) fs->super->s_reserved_gdt_blocks) + + (old_fs->desc_blocks - fs->desc_blocks); + if (new < 0) + new = 0; + if (new > (int) fs->blocksize/4) + new = fs->blocksize/4; + fs->super->s_reserved_gdt_blocks = new; + } +} + +/* Toggle 64bit mode */ +static errcode_t resize_group_descriptors(ext2_resize_t rfs, blk64_t new_size) +{ + void *o, *n, *new_group_desc; + dgrp_t i; + int copy_size; + errcode_t retval; + + if (!(rfs->flags & (RESIZE_DISABLE_64BIT | RESIZE_ENABLE_64BIT))) + return 0; + + if (new_size != ext2fs_blocks_count(rfs->new_fs->super) || + ext2fs_blocks_count(rfs->new_fs->super) >= (1ULL << 32) || + (rfs->flags & RESIZE_DISABLE_64BIT && + rfs->flags & RESIZE_ENABLE_64BIT)) + return EXT2_ET_INVALID_ARGUMENT; + + if (rfs->flags & RESIZE_DISABLE_64BIT) { + ext2fs_clear_feature_64bit(rfs->new_fs->super); + rfs->new_fs->super->s_desc_size = EXT2_MIN_DESC_SIZE; + } else if (rfs->flags & RESIZE_ENABLE_64BIT) { + ext2fs_set_feature_64bit(rfs->new_fs->super); + rfs->new_fs->super->s_desc_size = EXT2_MIN_DESC_SIZE_64BIT; + } + + if (EXT2_DESC_SIZE(rfs->old_fs->super) == + EXT2_DESC_SIZE(rfs->new_fs->super)) + return 0; + + o = rfs->new_fs->group_desc; + rfs->new_fs->desc_blocks = ext2fs_div_ceil( + rfs->old_fs->group_desc_count, + EXT2_DESC_PER_BLOCK(rfs->new_fs->super)); + retval = ext2fs_get_arrayzero(rfs->new_fs->desc_blocks, + rfs->old_fs->blocksize, &new_group_desc); + if (retval) + return retval; + + n = new_group_desc; + + if (EXT2_DESC_SIZE(rfs->old_fs->super) <= + EXT2_DESC_SIZE(rfs->new_fs->super)) + copy_size = EXT2_DESC_SIZE(rfs->old_fs->super); + else + copy_size = EXT2_DESC_SIZE(rfs->new_fs->super); + for (i = 0; i < rfs->old_fs->group_desc_count; i++) { + memcpy(n, o, copy_size); + n = (char *)n + EXT2_DESC_SIZE(rfs->new_fs->super); + o = (char *)o + EXT2_DESC_SIZE(rfs->old_fs->super); + } + + ext2fs_free_mem(&rfs->new_fs->group_desc); + rfs->new_fs->group_desc = new_group_desc; + + for (i = 0; i < rfs->old_fs->group_desc_count; i++) + ext2fs_group_desc_csum_set(rfs->new_fs, i); + + adjust_reserved_gdt_blocks(rfs->old_fs, rfs->new_fs); + + return 0; +} + +/* Move bitmaps/inode tables out of the way. */ +static errcode_t move_bg_metadata(ext2_resize_t rfs) +{ + dgrp_t i; + blk64_t b, c, d, old_desc_blocks, new_desc_blocks, j; + ext2fs_block_bitmap old_map, new_map; + int old, new; + errcode_t retval; + int cluster_ratio; + + if (!(rfs->flags & (RESIZE_DISABLE_64BIT | RESIZE_ENABLE_64BIT))) + return 0; + + retval = ext2fs_allocate_block_bitmap(rfs->old_fs, "oldfs", &old_map); + if (retval) + return retval; + + retval = ext2fs_allocate_block_bitmap(rfs->new_fs, "newfs", &new_map); + if (retval) + goto out; + + if (ext2fs_has_feature_meta_bg(rfs->old_fs->super)) { + old_desc_blocks = rfs->old_fs->super->s_first_meta_bg; + new_desc_blocks = rfs->new_fs->super->s_first_meta_bg; + } else { + old_desc_blocks = rfs->old_fs->desc_blocks + + rfs->old_fs->super->s_reserved_gdt_blocks; + new_desc_blocks = rfs->new_fs->desc_blocks + + rfs->new_fs->super->s_reserved_gdt_blocks; + } + + /* Construct bitmaps of super/descriptor blocks in old and new fs */ + for (i = 0; i < rfs->old_fs->group_desc_count; i++) { + retval = ext2fs_super_and_bgd_loc2(rfs->old_fs, i, &b, &c, &d, + NULL); + if (retval) + goto out; + if (b) + ext2fs_mark_block_bitmap2(old_map, b); + for (j = 0; c != 0 && j < old_desc_blocks; j++) + ext2fs_mark_block_bitmap2(old_map, c + j); + if (d) + ext2fs_mark_block_bitmap2(old_map, d); + + retval = ext2fs_super_and_bgd_loc2(rfs->new_fs, i, &b, &c, &d, + NULL); + if (retval) + goto out; + if (b) + ext2fs_mark_block_bitmap2(new_map, b); + for (j = 0; c != 0 && j < new_desc_blocks; j++) + ext2fs_mark_block_bitmap2(new_map, c + j); + if (d) + ext2fs_mark_block_bitmap2(new_map, d); + } + + cluster_ratio = EXT2FS_CLUSTER_RATIO(rfs->new_fs); + + /* Find changes in block allocations for bg metadata */ + for (b = EXT2FS_B2C(rfs->old_fs, + rfs->old_fs->super->s_first_data_block); + b < ext2fs_blocks_count(rfs->new_fs->super); + b += cluster_ratio) { + old = ext2fs_test_block_bitmap2(old_map, b); + new = ext2fs_test_block_bitmap2(new_map, b); + + if (old && !new) { + /* mark old_map, unmark new_map */ + if (cluster_ratio == 1) + ext2fs_unmark_block_bitmap2( + rfs->new_fs->block_map, b); + } else if (!old && new) + ; /* unmark old_map, mark new_map */ + else { + ext2fs_unmark_block_bitmap2(old_map, b); + ext2fs_unmark_block_bitmap2(new_map, b); + } + } + + /* + * new_map now shows blocks that have been newly allocated. + * old_map now shows blocks that have been newly freed. + */ + + /* + * Move any conflicting bitmaps and inode tables. Ensure that we + * don't try to free clusters associated with bitmaps or tables. + */ + for (i = 0; i < rfs->old_fs->group_desc_count; i++) { + b = ext2fs_block_bitmap_loc(rfs->new_fs, i); + if (ext2fs_test_block_bitmap2(new_map, b)) + ext2fs_block_bitmap_loc_set(rfs->new_fs, i, 0); + else if (ext2fs_test_block_bitmap2(old_map, b)) + ext2fs_unmark_block_bitmap2(old_map, b); + + b = ext2fs_inode_bitmap_loc(rfs->new_fs, i); + if (ext2fs_test_block_bitmap2(new_map, b)) + ext2fs_inode_bitmap_loc_set(rfs->new_fs, i, 0); + else if (ext2fs_test_block_bitmap2(old_map, b)) + ext2fs_unmark_block_bitmap2(old_map, b); + + c = ext2fs_inode_table_loc(rfs->new_fs, i); + for (b = 0; + b < rfs->new_fs->inode_blocks_per_group; + b++) { + if (ext2fs_test_block_bitmap2(new_map, b + c)) + ext2fs_inode_table_loc_set(rfs->new_fs, i, 0); + else if (ext2fs_test_block_bitmap2(old_map, b + c)) + ext2fs_unmark_block_bitmap2(old_map, b + c); + } + } + + /* Free unused clusters */ + for (b = 0; + cluster_ratio > 1 && b < ext2fs_blocks_count(rfs->new_fs->super); + b += cluster_ratio) + if (ext2fs_test_block_bitmap2(old_map, b)) + ext2fs_unmark_block_bitmap2(rfs->new_fs->block_map, b); +out: + if (old_map) + ext2fs_free_block_bitmap(old_map); + if (new_map) + ext2fs_free_block_bitmap(new_map); + return retval; +} + +/* Zero out the high bits of extent fields */ +static errcode_t zero_high_bits_in_extents(ext2_filsys fs, ext2_ino_t ino, + struct ext2_inode *inode) +{ + ext2_extent_handle_t handle; + struct ext2fs_extent extent; + int op = EXT2_EXTENT_ROOT; + errcode_t errcode; + + if (!(inode->i_flags & EXT4_EXTENTS_FL)) + return 0; + + errcode = ext2fs_extent_open(fs, ino, &handle); + if (errcode) + return errcode; + + while (1) { + errcode = ext2fs_extent_get(handle, op, &extent); + if (errcode) + break; + + op = EXT2_EXTENT_NEXT_SIB; + + if (extent.e_pblk > (1ULL << 32)) { + extent.e_pblk &= (1ULL << 32) - 1; + errcode = ext2fs_extent_replace(handle, 0, &extent); + if (errcode) + break; + } + } + + /* Ok if we run off the end */ + if (errcode == EXT2_ET_EXTENT_NO_NEXT) + errcode = 0; + ext2fs_extent_free(handle); + return errcode; +} + +/* Zero out the high bits of inodes. */ +static errcode_t zero_high_bits_in_inodes(ext2_resize_t rfs) +{ + ext2_filsys fs = rfs->old_fs; + int length = EXT2_INODE_SIZE(fs->super); + struct ext2_inode *inode = NULL; + ext2_inode_scan scan = NULL; + errcode_t retval; + ext2_ino_t ino; + + if (!(rfs->flags & (RESIZE_DISABLE_64BIT | RESIZE_ENABLE_64BIT))) + return 0; + + if (fs->super->s_creator_os == EXT2_OS_HURD) + return 0; + + retval = ext2fs_open_inode_scan(fs, 0, &scan); + if (retval) + return retval; + + retval = ext2fs_get_mem(length, &inode); + if (retval) + goto out; + + do { + retval = ext2fs_get_next_inode_full(scan, &ino, inode, length); + if (retval) + goto out; + if (!ino) + break; + if (!ext2fs_test_inode_bitmap2(fs->inode_map, ino)) + continue; + + /* + * Here's how we deal with high block number fields: + * + * - i_size_high has been been written out with i_size_lo + * since the ext2 days, so no conversion is needed. + * + * - i_blocks_hi is guarded by both the huge_file feature and + * inode flags and has always been written out with + * i_blocks_lo if the feature is set. The field is only + * ever read if both feature and inode flag are set, so + * we don't need to zero it now. + * + * - i_file_acl_high can be uninitialized, so zero it if + * it isn't already. + */ + if (inode->osd2.linux2.l_i_file_acl_high) { + inode->osd2.linux2.l_i_file_acl_high = 0; + retval = ext2fs_write_inode_full(fs, ino, inode, + length); + if (retval) + goto out; + } + + retval = zero_high_bits_in_extents(fs, ino, inode); + if (retval) + goto out; + } while (ino); + +out: + if (inode) + ext2fs_free_mem(&inode); + if (scan) + ext2fs_close_inode_scan(scan); + return retval; +} + +/* + * Clean up the bitmaps for uninitialized bitmaps + */ +static void fix_uninit_block_bitmaps(ext2_filsys fs) +{ + blk64_t blk, lblk; + dgrp_t g; + unsigned int i; + + if (!ext2fs_has_group_desc_csum(fs)) + return; + + for (g=0; g < fs->group_desc_count; g++) { + if (!(ext2fs_bg_flags_test(fs, g, EXT2_BG_BLOCK_UNINIT))) + continue; + + blk = ext2fs_group_first_block2(fs, g); + lblk = ext2fs_group_last_block2(fs, g); + ext2fs_unmark_block_bitmap_range2(fs->block_map, blk, + lblk - blk + 1); + + ext2fs_reserve_super_and_bgd(fs, g, fs->block_map); + ext2fs_mark_block_bitmap2(fs->block_map, + ext2fs_block_bitmap_loc(fs, g)); + ext2fs_mark_block_bitmap2(fs->block_map, + ext2fs_inode_bitmap_loc(fs, g)); + for (i = 0, blk = ext2fs_inode_table_loc(fs, g); + i < fs->inode_blocks_per_group; + i++, blk++) + ext2fs_mark_block_bitmap2(fs->block_map, blk); + } +} + +/* -------------------------------------------------------------------- + * + * Resize processing, phase 1. + * + * In this phase we adjust the in-memory superblock information, and + * initialize any new parts of the inode table. The new parts of the + * inode table are created in virgin disk space, so we can abort here + * without any side effects. + * -------------------------------------------------------------------- + */ + +/* + * If the group descriptor's bitmap and inode table blocks are valid, + * release them in the new filesystem data structure, and mark them as + * reserved so the old inode table blocks don't get overwritten. + */ +static errcode_t free_gdp_blocks(ext2_filsys fs, + ext2fs_block_bitmap reserve_blocks, + ext2_filsys old_fs, + dgrp_t group) +{ + blk64_t blk; + unsigned int j; + dgrp_t i; + ext2fs_block_bitmap bg_map = NULL; + errcode_t retval = 0; + dgrp_t count = old_fs->group_desc_count - fs->group_desc_count; + + /* If bigalloc, don't free metadata living in the same cluster */ + if (EXT2FS_CLUSTER_RATIO(fs) > 1) { + retval = ext2fs_allocate_block_bitmap(fs, "bgdata", &bg_map); + if (retval) + goto out; + + retval = mark_table_blocks(fs, bg_map); + if (retval) + goto out; + } + + for (i = group; i < group + count; i++) { + blk = ext2fs_block_bitmap_loc(old_fs, i); + if (blk && + (blk < ext2fs_blocks_count(fs->super)) && + !(bg_map && ext2fs_test_block_bitmap2(bg_map, blk))) { + ext2fs_block_alloc_stats2(fs, blk, -1); + ext2fs_mark_block_bitmap2(reserve_blocks, blk); + } + + blk = ext2fs_inode_bitmap_loc(old_fs, i); + if (blk && + (blk < ext2fs_blocks_count(fs->super)) && + !(bg_map && ext2fs_test_block_bitmap2(bg_map, blk))) { + ext2fs_block_alloc_stats2(fs, blk, -1); + ext2fs_mark_block_bitmap2(reserve_blocks, blk); + } + + blk = ext2fs_inode_table_loc(old_fs, i); + for (j = 0; + j < fs->inode_blocks_per_group; j++, blk++) { + if (blk >= ext2fs_blocks_count(fs->super) || + (bg_map && ext2fs_test_block_bitmap2(bg_map, blk))) + continue; + ext2fs_block_alloc_stats2(fs, blk, -1); + ext2fs_mark_block_bitmap2(reserve_blocks, blk); + } + } + +out: + if (bg_map) + ext2fs_free_block_bitmap(bg_map); + return retval; +} + +/* + * This routine is shared by the online and offline resize routines. + * All of the information which is adjusted in memory is done here. + */ +errcode_t adjust_fs_info(ext2_filsys fs, ext2_filsys old_fs, + ext2fs_block_bitmap reserve_blocks, blk64_t new_size) +{ + errcode_t retval; + blk64_t overhead = 0; + blk64_t rem; + blk64_t blk, group_block; + blk64_t real_end; + blk64_t old_numblocks, numblocks, adjblocks; + unsigned long i, j, old_desc_blocks; + unsigned int meta_bg, meta_bg_size; + int has_super, csum_flag, has_bg; + unsigned long long new_inodes; /* u64 to check for overflow */ + double percent; + + ext2fs_blocks_count_set(fs->super, new_size); + fs->super->s_overhead_clusters = 0; + +retry: + fs->group_desc_count = ext2fs_div64_ceil(ext2fs_blocks_count(fs->super) - + fs->super->s_first_data_block, + EXT2_BLOCKS_PER_GROUP(fs->super)); + if (fs->group_desc_count == 0) + return EXT2_ET_TOOSMALL; + fs->desc_blocks = ext2fs_div_ceil(fs->group_desc_count, + EXT2_DESC_PER_BLOCK(fs->super)); + + /* + * Overhead is the number of bookkeeping blocks per group. It + * includes the superblock backup, the group descriptor + * backups, the inode bitmap, the block bitmap, and the inode + * table. + */ + overhead = (int) (2 + fs->inode_blocks_per_group); + + has_bg = 0; + if (ext2fs_has_feature_sparse_super2(fs->super)) { + /* + * We have to do this manually since + * super->s_backup_bgs hasn't been set up yet. + */ + if (fs->group_desc_count == 2) + has_bg = fs->super->s_backup_bgs[0] != 0; + else + has_bg = fs->super->s_backup_bgs[1] != 0; + } else + has_bg = ext2fs_bg_has_super(fs, fs->group_desc_count - 1); + if (has_bg) + overhead += 1 + fs->desc_blocks + + fs->super->s_reserved_gdt_blocks; + + /* + * See if the last group is big enough to support the + * necessary data structures. If not, we need to get rid of + * it. + */ + rem = (ext2fs_blocks_count(fs->super) - fs->super->s_first_data_block) % + fs->super->s_blocks_per_group; + if ((fs->group_desc_count == 1) && rem && (rem < overhead)) + return EXT2_ET_TOOSMALL; + if ((fs->group_desc_count > 1) && rem && (rem < overhead+50)) { + ext2fs_blocks_count_set(fs->super, + ext2fs_blocks_count(fs->super) - rem); + goto retry; + } + /* + * Adjust the number of inodes + */ + new_inodes =(unsigned long long) fs->super->s_inodes_per_group * fs->group_desc_count; + if (new_inodes > ~0U) { + new_inodes = (unsigned long long) fs->super->s_inodes_per_group * (fs->group_desc_count - 1); + if (new_inodes <= ~0U) { + unsigned long long new_blocks = + ((unsigned long long) fs->super->s_blocks_per_group * + (fs->group_desc_count - 1)) + fs->super->s_first_data_block; + + ext2fs_blocks_count_set(fs->super, new_blocks); + goto retry; + } + fprintf(stderr, _("inodes (%llu) must be less than %u\n"), + (unsigned long long) new_inodes, ~0U); + return EXT2_ET_TOO_MANY_INODES; + } + fs->super->s_inodes_count = fs->super->s_inodes_per_group * + fs->group_desc_count; + + /* + * Adjust the number of free blocks + */ + blk = ext2fs_blocks_count(old_fs->super); + if (blk > ext2fs_blocks_count(fs->super)) + ext2fs_free_blocks_count_set(fs->super, + ext2fs_free_blocks_count(fs->super) - + (blk - ext2fs_blocks_count(fs->super))); + else + ext2fs_free_blocks_count_set(fs->super, + ext2fs_free_blocks_count(fs->super) + + (ext2fs_blocks_count(fs->super) - blk)); + + /* + * Adjust the number of reserved blocks + */ + percent = (ext2fs_r_blocks_count(old_fs->super) * 100.0) / + ext2fs_blocks_count(old_fs->super); + ext2fs_r_blocks_count_set(fs->super, + (percent * ext2fs_blocks_count(fs->super) / + 100.0)); + + /* + * Adjust the bitmaps for size + */ + retval = ext2fs_resize_inode_bitmap2(fs->super->s_inodes_count, + fs->super->s_inodes_count, + fs->inode_map); + if (retval) goto errout; + + real_end = EXT2_GROUPS_TO_BLOCKS(fs->super, fs->group_desc_count) - 1 + + fs->super->s_first_data_block; + retval = ext2fs_resize_block_bitmap2(new_size - 1, + real_end, fs->block_map); + if (retval) goto errout; + + /* + * If we are growing the file system, also grow the size of + * the reserve_blocks bitmap + */ + if (reserve_blocks && new_size > ext2fs_blocks_count(old_fs->super)) { + retval = ext2fs_resize_block_bitmap2(new_size - 1, + real_end, reserve_blocks); + if (retval) goto errout; + } + + /* + * Reallocate the group descriptors as necessary. + */ + if (EXT2_DESC_SIZE(old_fs->super) == EXT2_DESC_SIZE(fs->super) && + old_fs->desc_blocks != fs->desc_blocks) { + retval = ext2fs_resize_mem(old_fs->desc_blocks * + fs->blocksize, + fs->desc_blocks * fs->blocksize, + &fs->group_desc); + if (retval) + goto errout; + if (fs->desc_blocks > old_fs->desc_blocks) + memset((char *) fs->group_desc + + (old_fs->desc_blocks * fs->blocksize), 0, + (fs->desc_blocks - old_fs->desc_blocks) * + fs->blocksize); + } + + /* + * If the resize_inode feature is set, and we are changing the + * number of descriptor blocks, then adjust + * s_reserved_gdt_blocks if possible to avoid needing to move + * the inode table either now or in the future. + * + * Note: If we're converting to 64bit mode, we did this earlier. + */ + if (EXT2_DESC_SIZE(old_fs->super) == EXT2_DESC_SIZE(fs->super)) + adjust_reserved_gdt_blocks(old_fs, fs); + + if (ext2fs_has_feature_meta_bg(fs->super) && + (fs->super->s_first_meta_bg > fs->desc_blocks)) { + ext2fs_clear_feature_meta_bg(fs->super); + fs->super->s_first_meta_bg = 0; + } + + /* + * Update the location of the backup superblocks if the + * sparse_super2 feature is enabled. + */ + if (ext2fs_has_feature_sparse_super2(fs->super)) { + dgrp_t last_bg = fs->group_desc_count - 1; + dgrp_t old_last_bg = old_fs->group_desc_count - 1; + + if (last_bg > old_last_bg) { + if (old_fs->group_desc_count == 1) + fs->super->s_backup_bgs[0] = 1; + if ((old_fs->group_desc_count < 3 && + fs->group_desc_count > 2) || + fs->super->s_backup_bgs[1]) + fs->super->s_backup_bgs[1] = last_bg; + } else if (last_bg < old_last_bg) { + if (fs->super->s_backup_bgs[0] > last_bg) + fs->super->s_backup_bgs[0] = 0; + if (fs->super->s_backup_bgs[1] > last_bg) + fs->super->s_backup_bgs[1] = 0; + if (last_bg > 1 && + old_fs->super->s_backup_bgs[1] == old_last_bg) + fs->super->s_backup_bgs[1] = last_bg; + } + } + + /* + * If we are shrinking the number of block groups, we're done + * and can exit now. + */ + if (old_fs->group_desc_count > fs->group_desc_count) { + /* + * Check the block groups that we are chopping off + * and free any blocks associated with their metadata + */ + retval = free_gdp_blocks(fs, reserve_blocks, old_fs, + fs->group_desc_count); + goto errout; + } + + /* + * Fix the count of the last (old) block group + */ + old_numblocks = (ext2fs_blocks_count(old_fs->super) - + old_fs->super->s_first_data_block) % + old_fs->super->s_blocks_per_group; + if (!old_numblocks) + old_numblocks = old_fs->super->s_blocks_per_group; + if (old_fs->group_desc_count == fs->group_desc_count) { + numblocks = (ext2fs_blocks_count(fs->super) - + fs->super->s_first_data_block) % + fs->super->s_blocks_per_group; + if (!numblocks) + numblocks = fs->super->s_blocks_per_group; + } else + numblocks = fs->super->s_blocks_per_group; + i = old_fs->group_desc_count - 1; + ext2fs_bg_free_blocks_count_set(fs, i, ext2fs_bg_free_blocks_count(fs, i) + (numblocks - old_numblocks)); + ext2fs_group_desc_csum_set(fs, i); + + /* + * If the number of block groups is staying the same, we're + * done and can exit now. (If the number block groups is + * shrinking, we had exited earlier.) + */ + if (old_fs->group_desc_count >= fs->group_desc_count) { + retval = 0; + goto errout; + } + + /* + * Initialize the new block group descriptors + */ + group_block = ext2fs_group_first_block2(fs, + old_fs->group_desc_count); + csum_flag = ext2fs_has_group_desc_csum(fs); + if (getenv("RESIZE2FS_FORCE_LAZY_ITABLE_INIT") || + (!getenv("RESIZE2FS_FORCE_ITABLE_INIT") && + access("/sys/fs/ext4/features/lazy_itable_init", F_OK) == 0)) + lazy_itable_init = 1; + if (ext2fs_has_feature_meta_bg(fs->super)) + old_desc_blocks = fs->super->s_first_meta_bg; + else + old_desc_blocks = fs->desc_blocks + + fs->super->s_reserved_gdt_blocks; + + /* + * If we changed the number of block_group descriptor blocks, + * we need to make sure they are all marked as reserved in the + * filesystem's block allocation map. + */ + for (i = 0; i < old_fs->group_desc_count; i++) + ext2fs_reserve_super_and_bgd(fs, i, fs->block_map); + + for (i = old_fs->group_desc_count; + i < fs->group_desc_count; i++) { + memset(ext2fs_group_desc(fs, fs->group_desc, i), 0, + sizeof(struct ext2_group_desc)); + adjblocks = 0; + + ext2fs_bg_flags_zap(fs, i); + if (csum_flag) { + ext2fs_bg_flags_set(fs, i, EXT2_BG_INODE_UNINIT); + if (!lazy_itable_init) + ext2fs_bg_flags_set(fs, i, + EXT2_BG_INODE_ZEROED); + ext2fs_bg_itable_unused_set(fs, i, + fs->super->s_inodes_per_group); + } + + numblocks = ext2fs_group_blocks_count(fs, i); + if ((i < fs->group_desc_count - 1) && csum_flag) + ext2fs_bg_flags_set(fs, i, EXT2_BG_BLOCK_UNINIT); + + has_super = ext2fs_bg_has_super(fs, i); + if (has_super) { + ext2fs_block_alloc_stats2(fs, group_block, +1); + adjblocks++; + } + meta_bg_size = EXT2_DESC_PER_BLOCK(fs->super); + meta_bg = i / meta_bg_size; + if (!ext2fs_has_feature_meta_bg(fs->super) || + (meta_bg < fs->super->s_first_meta_bg)) { + if (has_super) { + for (j=0; j < old_desc_blocks; j++) + ext2fs_block_alloc_stats2(fs, + group_block + 1 + j, +1); + adjblocks += old_desc_blocks; + } + } else { + if (has_super) + has_super = 1; + if (((i % meta_bg_size) == 0) || + ((i % meta_bg_size) == 1) || + ((i % meta_bg_size) == (meta_bg_size-1))) + ext2fs_block_alloc_stats2(fs, + group_block + has_super, +1); + } + + adjblocks += 2 + fs->inode_blocks_per_group; + + numblocks -= adjblocks; + ext2fs_free_blocks_count_set(fs->super, + ext2fs_free_blocks_count(fs->super) - adjblocks); + fs->super->s_free_inodes_count += + fs->super->s_inodes_per_group; + ext2fs_bg_free_blocks_count_set(fs, i, numblocks); + ext2fs_bg_free_inodes_count_set(fs, i, + fs->super->s_inodes_per_group); + ext2fs_bg_used_dirs_count_set(fs, i, 0); + ext2fs_group_desc_csum_set(fs, i); + + retval = ext2fs_allocate_group_table(fs, i, 0); + if (retval) goto errout; + + group_block += fs->super->s_blocks_per_group; + } + retval = 0; + + /* + * Mark all of the metadata blocks as reserved so they won't + * get allocated by the call to ext2fs_allocate_group_table() + * in blocks_to_move(), where we allocate new blocks to + * replace those allocation bitmap and inode table blocks + * which have to get relocated to make space for an increased + * number of the block group descriptors. + */ + if (reserve_blocks) + mark_table_blocks(fs, reserve_blocks); + +errout: + return (retval); +} + +/* + * Replicate the first part of adjust_fs_info to determine what the + * new size of the file system should be. This allows resize2fs to + * exit early if we aren't going to make any changes to the file + * system. + */ +void adjust_new_size(ext2_filsys fs, blk64_t *sizep) +{ + blk64_t size, rem, overhead = 0; + unsigned long desc_blocks; + dgrp_t group_desc_count; + int has_bg; + unsigned long long new_inodes; /* u64 to check for overflow */ + + size = *sizep; +retry: + group_desc_count = ext2fs_div64_ceil(size - + fs->super->s_first_data_block, + EXT2_BLOCKS_PER_GROUP(fs->super)); + if (group_desc_count == 0) + return; + desc_blocks = ext2fs_div_ceil(group_desc_count, + EXT2_DESC_PER_BLOCK(fs->super)); + + /* + * Overhead is the number of bookkeeping blocks per group. It + * includes the superblock backup, the group descriptor + * backups, the inode bitmap, the block bitmap, and the inode + * table. + */ + overhead = (int) (2 + fs->inode_blocks_per_group); + + has_bg = 0; + if (ext2fs_has_feature_sparse_super2(fs->super)) { + /* + * We have to do this manually since + * super->s_backup_bgs hasn't been set up yet. + */ + if (group_desc_count == 2) + has_bg = fs->super->s_backup_bgs[0] != 0; + else + has_bg = fs->super->s_backup_bgs[1] != 0; + } else + has_bg = ext2fs_bg_has_super(fs, group_desc_count - 1); + if (has_bg) + overhead += 1 + desc_blocks + + fs->super->s_reserved_gdt_blocks; + + /* + * See if the last group is big enough to support the + * necessary data structures. If not, we need to get rid of + * it. + */ + rem = (size - fs->super->s_first_data_block) % + fs->super->s_blocks_per_group; + if ((group_desc_count == 1) && rem && (rem < overhead)) + return; + if ((group_desc_count > 1) && rem && (rem < overhead+50)) { + size -= rem; + goto retry; + } + + /* + * If we need to reduce the size by no more than a block + * group to avoid overrunning the max inode limit, do it. + */ + new_inodes =(unsigned long long) fs->super->s_inodes_per_group * group_desc_count; + if (new_inodes > ~0U) { + new_inodes = (unsigned long long) fs->super->s_inodes_per_group * (group_desc_count - 1); + if (new_inodes > ~0U) + return; + size = ((unsigned long long) fs->super->s_blocks_per_group * + (group_desc_count - 1)) + fs->super->s_first_data_block; + + goto retry; + } + *sizep = size; +} + +/* + * This routine adjusts the superblock and other data structures, both + * in disk as well as in memory... + */ +static errcode_t adjust_superblock(ext2_resize_t rfs, blk64_t new_size) +{ + ext2_filsys fs = rfs->new_fs; + int adj = 0; + errcode_t retval; + unsigned long i; + unsigned long max_group; + + ext2fs_mark_super_dirty(fs); + ext2fs_mark_bb_dirty(fs); + ext2fs_mark_ib_dirty(fs); + + retval = ext2fs_allocate_block_bitmap(fs, _("reserved blocks"), + &rfs->reserve_blocks); + if (retval) + return retval; + + retval = adjust_fs_info(fs, rfs->old_fs, rfs->reserve_blocks, new_size); + if (retval) + goto errout; + + /* + * Check to make sure there are enough inodes + */ + if ((rfs->old_fs->super->s_inodes_count - + rfs->old_fs->super->s_free_inodes_count) > + rfs->new_fs->super->s_inodes_count) { + retval = ENOSPC; + goto errout; + } + + /* + * If we are shrinking the number block groups, we're done and + * can exit now. + */ + if (rfs->old_fs->group_desc_count > fs->group_desc_count) { + retval = 0; + goto errout; + } + + /* + * If the number of block groups is staying the same, we're + * done and can exit now. (If the number block groups is + * shrinking, we had exited earlier.) + */ + if (rfs->old_fs->group_desc_count >= fs->group_desc_count) { + retval = 0; + goto errout; + } + + /* + * If we are using uninit_bg (aka GDT_CSUM) and the kernel + * supports lazy inode initialization, we can skip + * initializing the inode table. + */ + if (lazy_itable_init && ext2fs_has_group_desc_csum(fs)) { + retval = 0; + goto errout; + } + + /* + * Initialize the inode table + */ + retval = ext2fs_get_array(fs->blocksize, fs->inode_blocks_per_group, + &rfs->itable_buf); + if (retval) + goto errout; + + memset(rfs->itable_buf, 0, fs->blocksize * fs->inode_blocks_per_group); + adj = rfs->old_fs->group_desc_count; + max_group = fs->group_desc_count - adj; + if (rfs->progress) { + retval = rfs->progress(rfs, E2_RSZ_EXTEND_ITABLE_PASS, + 0, max_group); + if (retval) + goto errout; + } + for (i = rfs->old_fs->group_desc_count; + i < fs->group_desc_count; i++) { + /* + * Write out the new inode table + */ + retval = ext2fs_zero_blocks2(fs, ext2fs_inode_table_loc(fs, i), + fs->inode_blocks_per_group, NULL, + NULL); + if (retval) + goto errout; + + io_channel_flush(fs->io); + if (rfs->progress) { + retval = rfs->progress(rfs, E2_RSZ_EXTEND_ITABLE_PASS, + i - adj + 1, max_group); + if (retval) + goto errout; + } + } + io_channel_flush(fs->io); + retval = 0; + +errout: + return retval; +} + +/* -------------------------------------------------------------------- + * + * Resize processing, phase 2. + * + * In this phase we adjust determine which blocks need to be moved, in + * blocks_to_move(). We then copy the blocks to their ultimate new + * destinations using block_mover(). Since we are copying blocks to + * their new locations, again during this pass we can abort without + * any problems. + * -------------------------------------------------------------------- + */ + +/* + * This helper function creates a block bitmap with all of the + * filesystem meta-data blocks. + */ +static errcode_t mark_table_blocks(ext2_filsys fs, + ext2fs_block_bitmap bmap) +{ + dgrp_t i; + blk64_t blk; + + for (i = 0; i < fs->group_desc_count; i++) { + ext2fs_reserve_super_and_bgd(fs, i, bmap); + + /* + * Mark the blocks used for the inode table + */ + blk = ext2fs_inode_table_loc(fs, i); + if (blk) + ext2fs_mark_block_bitmap_range2(bmap, blk, + fs->inode_blocks_per_group); + + /* + * Mark block used for the block bitmap + */ + blk = ext2fs_block_bitmap_loc(fs, i); + if (blk) + ext2fs_mark_block_bitmap2(bmap, blk); + + /* + * Mark block used for the inode bitmap + */ + blk = ext2fs_inode_bitmap_loc(fs, i); + if (blk) + ext2fs_mark_block_bitmap2(bmap, blk); + } + /* Reserve the MMP block */ + if (ext2fs_has_feature_mmp(fs->super) && + fs->super->s_mmp_block > fs->super->s_first_data_block && + fs->super->s_mmp_block < ext2fs_blocks_count(fs->super)) + ext2fs_mark_block_bitmap2(bmap, fs->super->s_mmp_block); + return 0; +} + +/* + * This function checks to see if a particular block (either a + * superblock or a block group descriptor) overlaps with an inode or + * block bitmap block, or with the inode table. + */ +static void mark_fs_metablock(ext2_resize_t rfs, + ext2fs_block_bitmap meta_bmap, + int group, blk64_t blk) +{ + ext2_filsys fs = rfs->new_fs; + + ext2fs_mark_block_bitmap2(rfs->reserve_blocks, blk); + ext2fs_block_alloc_stats2(fs, blk, +1); + + /* + * Check to see if we overlap with the inode or block bitmap, + * or the inode tables. If not, and the block is in use, then + * mark it as a block to be moved. + */ + if (is_block_bm(fs, group, blk)) { + ext2fs_block_bitmap_loc_set(fs, group, 0); + rfs->needed_blocks++; + return; + } + if (is_inode_bm(fs, group, blk)) { + ext2fs_inode_bitmap_loc_set(fs, group, 0); + rfs->needed_blocks++; + return; + } + if (is_inode_tb(fs, group, blk)) { + ext2fs_inode_table_loc_set(fs, group, 0); + rfs->needed_blocks++; + return; + } + if (ext2fs_has_feature_flex_bg(fs->super)) { + dgrp_t i; + + for (i = 0; i < rfs->old_fs->group_desc_count; i++) { + if (is_block_bm(fs, i, blk)) { + ext2fs_block_bitmap_loc_set(fs, i, 0); + rfs->needed_blocks++; + return; + } + if (is_inode_bm(fs, i, blk)) { + ext2fs_inode_bitmap_loc_set(fs, i, 0); + rfs->needed_blocks++; + return; + } + if (is_inode_tb(fs, i, blk)) { + ext2fs_inode_table_loc_set(fs, i, 0); + rfs->needed_blocks++; + return; + } + } + } + + if (ext2fs_has_group_desc_csum(fs) && + (ext2fs_bg_flags_test(fs, group, EXT2_BG_BLOCK_UNINIT))) { + /* + * If the block bitmap is uninitialized, which means + * nothing other than standard metadata in use. + */ + return; + } else if (blk < ext2fs_blocks_count(rfs->old_fs->super) && + ext2fs_test_block_bitmap2(rfs->old_fs->block_map, blk) && + !ext2fs_test_block_bitmap2(meta_bmap, blk)) { + ext2fs_mark_block_bitmap2(rfs->move_blocks, blk); + rfs->needed_blocks++; + } +} + + +/* + * This routine marks and unmarks reserved blocks in the new block + * bitmap. It also determines which blocks need to be moved and + * places this information into the move_blocks bitmap. + */ +static errcode_t blocks_to_move(ext2_resize_t rfs) +{ + unsigned int j; + int has_super; + dgrp_t i, max_groups, g; + blk64_t blk, group_blk; + blk64_t old_blocks, new_blocks, group_end, cluster_freed; + blk64_t new_size; + unsigned int meta_bg, meta_bg_size; + errcode_t retval; + ext2_filsys fs, old_fs; + ext2fs_block_bitmap meta_bmap, new_meta_bmap = NULL; + int flex_bg; + + fs = rfs->new_fs; + old_fs = rfs->old_fs; + if (ext2fs_blocks_count(old_fs->super) > ext2fs_blocks_count(fs->super)) + fs = rfs->old_fs; + + retval = ext2fs_allocate_block_bitmap(fs, _("blocks to be moved"), + &rfs->move_blocks); + if (retval) + return retval; + + retval = ext2fs_allocate_block_bitmap(fs, _("meta-data blocks"), + &meta_bmap); + if (retval) + return retval; + + retval = mark_table_blocks(old_fs, meta_bmap); + if (retval) + return retval; + + fs = rfs->new_fs; + + /* + * If we're shrinking the filesystem, we need to move any + * group's metadata blocks (either allocation bitmaps or the + * inode table) which are beyond the end of the new + * filesystem. + */ + new_size = ext2fs_blocks_count(fs->super); + if (new_size < ext2fs_blocks_count(old_fs->super)) { + for (g = 0; g < fs->group_desc_count; g++) { + int realloc = 0; + /* + * ext2fs_allocate_group_table will re-allocate any + * metadata blocks whose location is set to zero. + */ + if (ext2fs_block_bitmap_loc(fs, g) >= new_size) { + ext2fs_block_bitmap_loc_set(fs, g, 0); + realloc = 1; + } + if (ext2fs_inode_bitmap_loc(fs, g) >= new_size) { + ext2fs_inode_bitmap_loc_set(fs, g, 0); + realloc = 1; + } + if ((ext2fs_inode_table_loc(fs, g) + + fs->inode_blocks_per_group) > new_size) { + ext2fs_inode_table_loc_set(fs, g, 0); + realloc = 1; + } + + if (realloc) { + retval = ext2fs_allocate_group_table(fs, g, 0); + if (retval) + return retval; + } + } + } + + /* + * If we're shrinking the filesystem, we need to move all of + * the blocks that don't fit any more + */ + for (blk = ext2fs_blocks_count(fs->super); + blk < ext2fs_blocks_count(old_fs->super); blk++) { + g = ext2fs_group_of_blk2(fs, blk); + if (ext2fs_has_group_desc_csum(fs) && + ext2fs_bg_flags_test(old_fs, g, EXT2_BG_BLOCK_UNINIT)) { + /* + * The block bitmap is uninitialized, so skip + * to the next block group. + */ + blk = ext2fs_group_first_block2(fs, g+1) - 1; + continue; + } + if (ext2fs_test_block_bitmap2(old_fs->block_map, blk) && + !ext2fs_test_block_bitmap2(meta_bmap, blk)) { + ext2fs_mark_block_bitmap2(rfs->move_blocks, blk); + rfs->needed_blocks++; + } + ext2fs_mark_block_bitmap2(rfs->reserve_blocks, blk); + } + + if (ext2fs_has_feature_meta_bg(old_fs->super)) + old_blocks = old_fs->super->s_first_meta_bg; + else + old_blocks = old_fs->desc_blocks + + old_fs->super->s_reserved_gdt_blocks; + if (ext2fs_has_feature_meta_bg(fs->super)) + new_blocks = fs->super->s_first_meta_bg; + else + new_blocks = fs->desc_blocks + fs->super->s_reserved_gdt_blocks; + + retval = reserve_sparse_super2_last_group(rfs, meta_bmap); + if (retval) + goto errout; + + if (EXT2_DESC_SIZE(rfs->old_fs->super) == + EXT2_DESC_SIZE(rfs->new_fs->super) && + old_blocks == new_blocks) { + retval = 0; + goto errout; + } + + max_groups = fs->group_desc_count; + if (max_groups > old_fs->group_desc_count) + max_groups = old_fs->group_desc_count; + group_blk = old_fs->super->s_first_data_block; + /* + * If we're reducing the number of descriptor blocks, this + * makes life easy. :-) We just have to mark some extra + * blocks as free. + */ + if (old_blocks > new_blocks) { + if (EXT2FS_CLUSTER_RATIO(fs) > 1) { + retval = ext2fs_allocate_block_bitmap(fs, + _("new meta blocks"), + &new_meta_bmap); + if (retval) + goto errout; + + retval = mark_table_blocks(fs, new_meta_bmap); + if (retval) + goto errout; + } + + for (i = 0; i < max_groups; i++) { + if (!ext2fs_bg_has_super(old_fs, i)) { + group_blk += fs->super->s_blocks_per_group; + continue; + } + group_end = group_blk + 1 + old_blocks; + for (blk = group_blk + 1 + new_blocks; + blk < group_end;) { + if (new_meta_bmap == NULL || + !ext2fs_test_block_bitmap2(new_meta_bmap, + blk)) { + cluster_freed = + EXT2FS_CLUSTER_RATIO(fs) - + (blk & + EXT2FS_CLUSTER_MASK(fs)); + if (cluster_freed > group_end - blk) + cluster_freed = group_end - blk; + ext2fs_block_alloc_stats2(fs, blk, -1); + blk += EXT2FS_CLUSTER_RATIO(fs); + rfs->needed_blocks -= cluster_freed; + continue; + } + rfs->needed_blocks--; + blk++; + } + group_blk += fs->super->s_blocks_per_group; + } + retval = 0; + goto errout; + } + /* + * If we're increasing the number of descriptor blocks, life + * gets interesting.... + */ + meta_bg_size = EXT2_DESC_PER_BLOCK(fs->super); + flex_bg = ext2fs_has_feature_flex_bg(fs->super); + /* first reserve all of the existing fs meta blocks */ + for (i = 0; i < max_groups; i++) { + has_super = ext2fs_bg_has_super(fs, i); + if (has_super) + mark_fs_metablock(rfs, meta_bmap, i, group_blk); + + meta_bg = i / meta_bg_size; + if (!ext2fs_has_feature_meta_bg(fs->super) || + (meta_bg < fs->super->s_first_meta_bg)) { + if (has_super) { + for (blk = group_blk+1; + blk < group_blk + 1 + new_blocks; blk++) + mark_fs_metablock(rfs, meta_bmap, + i, blk); + } + } else { + if (has_super) + has_super = 1; + if (((i % meta_bg_size) == 0) || + ((i % meta_bg_size) == 1) || + ((i % meta_bg_size) == (meta_bg_size-1))) + mark_fs_metablock(rfs, meta_bmap, i, + group_blk + has_super); + } + + /* + * Reserve the existing meta blocks that we know + * aren't to be moved. + * + * For flex_bg file systems, in order to avoid + * overwriting fs metadata (especially inode table + * blocks) belonging to a different block group when + * we are relocating the inode tables, we need to + * reserve all existing fs metadata blocks. + */ + if (ext2fs_block_bitmap_loc(fs, i)) + ext2fs_mark_block_bitmap2(rfs->reserve_blocks, + ext2fs_block_bitmap_loc(fs, i)); + else if (flex_bg && i < old_fs->group_desc_count) + ext2fs_mark_block_bitmap2(rfs->reserve_blocks, + ext2fs_block_bitmap_loc(old_fs, i)); + + if (ext2fs_inode_bitmap_loc(fs, i)) + ext2fs_mark_block_bitmap2(rfs->reserve_blocks, + ext2fs_inode_bitmap_loc(fs, i)); + else if (flex_bg && i < old_fs->group_desc_count) + ext2fs_mark_block_bitmap2(rfs->reserve_blocks, + ext2fs_inode_bitmap_loc(old_fs, i)); + + if (ext2fs_inode_table_loc(fs, i)) + ext2fs_mark_block_bitmap_range2(rfs->reserve_blocks, + ext2fs_inode_table_loc(fs, i), + fs->inode_blocks_per_group); + else if (flex_bg && i < old_fs->group_desc_count) + ext2fs_mark_block_bitmap_range2(rfs->reserve_blocks, + ext2fs_inode_table_loc(old_fs, i), + old_fs->inode_blocks_per_group); + + group_blk += rfs->new_fs->super->s_blocks_per_group; + } + + /* Allocate the missing data structures */ + for (i = 0; i < max_groups; i++) { + if (ext2fs_inode_table_loc(fs, i) && + ext2fs_inode_bitmap_loc(fs, i) && + ext2fs_block_bitmap_loc(fs, i)) + continue; + + retval = ext2fs_allocate_group_table(fs, i, + rfs->reserve_blocks); + if (retval) + goto errout; + + /* + * For those structures that have changed, we need to + * do bookkeeping. + */ + if (ext2fs_block_bitmap_loc(old_fs, i) != + (blk = ext2fs_block_bitmap_loc(fs, i))) { + ext2fs_block_alloc_stats2(fs, blk, +1); + if (blk < ext2fs_blocks_count(old_fs->super) && + ext2fs_test_block_bitmap2(old_fs->block_map, blk) && + !ext2fs_test_block_bitmap2(meta_bmap, blk)) + ext2fs_mark_block_bitmap2(rfs->move_blocks, + blk); + } + if (ext2fs_inode_bitmap_loc(old_fs, i) != + (blk = ext2fs_inode_bitmap_loc(fs, i))) { + ext2fs_block_alloc_stats2(fs, blk, +1); + if (blk < ext2fs_blocks_count(old_fs->super) && + ext2fs_test_block_bitmap2(old_fs->block_map, blk) && + !ext2fs_test_block_bitmap2(meta_bmap, blk)) + ext2fs_mark_block_bitmap2(rfs->move_blocks, + blk); + } + + /* + * The inode table, if we need to relocate it, is + * handled specially. We have to reserve the blocks + * for both the old and the new inode table, since we + * can't have the inode table be destroyed during the + * block relocation phase. + */ + if (ext2fs_inode_table_loc(fs, i) == ext2fs_inode_table_loc(old_fs, i)) + continue; /* inode table not moved */ + + rfs->needed_blocks += fs->inode_blocks_per_group; + + /* + * Mark the new inode table as in use in the new block + * allocation bitmap, and move any blocks that might + * be necessary. + */ + for (blk = ext2fs_inode_table_loc(fs, i), j=0; + j < fs->inode_blocks_per_group ; j++, blk++) { + ext2fs_block_alloc_stats2(fs, blk, +1); + if (blk < ext2fs_blocks_count(old_fs->super) && + ext2fs_test_block_bitmap2(old_fs->block_map, blk) && + !ext2fs_test_block_bitmap2(meta_bmap, blk)) + ext2fs_mark_block_bitmap2(rfs->move_blocks, + blk); + } + + /* + * Make sure the old inode table is reserved in the + * block reservation bitmap. + */ + for (blk = ext2fs_inode_table_loc(rfs->old_fs, i), j=0; + j < fs->inode_blocks_per_group ; j++, blk++) + ext2fs_mark_block_bitmap2(rfs->reserve_blocks, blk); + } + retval = 0; + +errout: + if (new_meta_bmap) + ext2fs_free_block_bitmap(new_meta_bmap); + if (meta_bmap) + ext2fs_free_block_bitmap(meta_bmap); + + return retval; +} + +/* + * This helper function tries to allocate a new block. We try to + * avoid hitting the original group descriptor blocks at least at + * first, since we want to make it possible to recover from a badly + * aborted resize operation as much as possible. + * + * In the future, I may further modify this routine to balance out + * where we get the new blocks across the various block groups. + * Ideally we would allocate blocks that corresponded with the block + * group of the containing inode, and keep contiguous blocks + * together. However, this very difficult to do efficiently, since we + * don't have the necessary information up front. + */ + +#define AVOID_OLD 1 +#define DESPERATION 2 + +static void init_block_alloc(ext2_resize_t rfs) +{ + rfs->alloc_state = AVOID_OLD; + rfs->new_blk = rfs->new_fs->super->s_first_data_block; +#if 0 + /* HACK for testing */ + if (ext2fs_blocks_count(rfs->new_fs->super) > + ext2fs_blocks_count(rfs->old_fs->super)) + rfs->new_blk = ext2fs_blocks_count(rfs->old_fs->super); +#endif +} + +static blk64_t get_new_block(ext2_resize_t rfs) +{ + ext2_filsys fs = rfs->new_fs; + + while (1) { + if (rfs->new_blk >= ext2fs_blocks_count(fs->super)) { + if (rfs->alloc_state == DESPERATION) + return 0; + +#ifdef RESIZE2FS_DEBUG + if (rfs->flags & RESIZE_DEBUG_BMOVE) + printf("Going into desperation mode " + "for block allocations\n"); +#endif + rfs->alloc_state = DESPERATION; + rfs->new_blk = fs->super->s_first_data_block; + continue; + } + if (ext2fs_test_block_bitmap2(fs->block_map, rfs->new_blk) || + ext2fs_test_block_bitmap2(rfs->reserve_blocks, + rfs->new_blk) || + ((rfs->alloc_state == AVOID_OLD) && + (rfs->new_blk < ext2fs_blocks_count(rfs->old_fs->super)) && + ext2fs_test_block_bitmap2(rfs->old_fs->block_map, + rfs->new_blk))) { + rfs->new_blk++; + continue; + } + return rfs->new_blk; + } +} + +static errcode_t resize2fs_get_alloc_block(ext2_filsys fs, + blk64_t goal EXT2FS_ATTR((unused)), + blk64_t *ret) +{ + ext2_resize_t rfs = (ext2_resize_t) fs->priv_data; + blk64_t blk; + int group; + + blk = get_new_block(rfs); + if (!blk) + return ENOSPC; + +#ifdef RESIZE2FS_DEBUG + if (rfs->flags & 0xF) + printf("get_alloc_block allocating %llu\n", + (unsigned long long) blk); +#endif + + ext2fs_mark_block_bitmap2(rfs->old_fs->block_map, blk); + ext2fs_mark_block_bitmap2(rfs->new_fs->block_map, blk); + + group = ext2fs_group_of_blk2(rfs->old_fs, blk); + ext2fs_clear_block_uninit(rfs->old_fs, group); + group = ext2fs_group_of_blk2(rfs->new_fs, blk); + ext2fs_clear_block_uninit(rfs->new_fs, group); + + *ret = (blk64_t) blk; + return 0; +} + +static errcode_t block_mover(ext2_resize_t rfs) +{ + blk64_t blk, old_blk, new_blk; + ext2_filsys fs = rfs->new_fs; + ext2_filsys old_fs = rfs->old_fs; + errcode_t retval; + __u64 c, size; + int to_move, moved; + ext2_badblocks_list badblock_list = 0; + int bb_modified = 0; + + fs->get_alloc_block = resize2fs_get_alloc_block; + old_fs->get_alloc_block = resize2fs_get_alloc_block; + + retval = ext2fs_read_bb_inode(old_fs, &badblock_list); + if (retval) + return retval; + + new_blk = fs->super->s_first_data_block; + if (!rfs->itable_buf) { + retval = ext2fs_get_array(fs->blocksize, + fs->inode_blocks_per_group, + &rfs->itable_buf); + if (retval) + goto errout; + } + retval = ext2fs_create_extent_table(&rfs->bmap, 0); + if (retval) + goto errout; + + /* + * The first step is to figure out where all of the blocks + * will go. + */ + to_move = moved = 0; + init_block_alloc(rfs); + for (blk = B2C(old_fs->super->s_first_data_block); + blk < ext2fs_blocks_count(old_fs->super); + blk += EXT2FS_CLUSTER_RATIO(fs)) { + if (!ext2fs_test_block_bitmap2(old_fs->block_map, blk)) + continue; + if (!ext2fs_test_block_bitmap2(rfs->move_blocks, blk)) + continue; + if (ext2fs_badblocks_list_test(badblock_list, blk)) { + ext2fs_badblocks_list_del(badblock_list, blk); + bb_modified++; + continue; + } + + new_blk = get_new_block(rfs); + if (!new_blk) { + retval = ENOSPC; + goto errout; + } + ext2fs_block_alloc_stats2(fs, new_blk, +1); + ext2fs_add_extent_entry(rfs->bmap, B2C(blk), B2C(new_blk)); + to_move++; + } + + if (to_move == 0) { + if (rfs->bmap) { + ext2fs_free_extent_table(rfs->bmap); + rfs->bmap = 0; + } + retval = 0; + goto errout; + } + + /* + * Step two is to actually move the blocks + */ + retval = ext2fs_iterate_extent(rfs->bmap, 0, 0, 0); + if (retval) goto errout; + + if (rfs->progress) { + retval = (rfs->progress)(rfs, E2_RSZ_BLOCK_RELOC_PASS, + 0, to_move); + if (retval) + goto errout; + } + while (1) { + retval = ext2fs_iterate_extent(rfs->bmap, &old_blk, &new_blk, &size); + if (retval) goto errout; + if (!size) + break; + old_blk = C2B(old_blk); + new_blk = C2B(new_blk); + size = C2B(size); +#ifdef RESIZE2FS_DEBUG + if (rfs->flags & RESIZE_DEBUG_BMOVE) + printf("Moving %llu blocks %llu->%llu\n", + (unsigned long long) size, + (unsigned long long) old_blk, + (unsigned long long) new_blk); +#endif + do { + c = size; + if (c > fs->inode_blocks_per_group) + c = fs->inode_blocks_per_group; + retval = io_channel_read_blk64(fs->io, old_blk, c, + rfs->itable_buf); + if (retval) goto errout; + retval = io_channel_write_blk64(fs->io, new_blk, c, + rfs->itable_buf); + if (retval) goto errout; + size -= c; + new_blk += c; + old_blk += c; + moved += c; + if (rfs->progress) { + io_channel_flush(fs->io); + retval = (rfs->progress)(rfs, + E2_RSZ_BLOCK_RELOC_PASS, + moved, to_move); + if (retval) + goto errout; + } + } while (size > 0); + io_channel_flush(fs->io); + } + +errout: + if (badblock_list) { + if (!retval && bb_modified) + retval = ext2fs_update_bb_inode(old_fs, + badblock_list); + ext2fs_badblocks_list_free(badblock_list); + } + return retval; +} + + +/* -------------------------------------------------------------------- + * + * Resize processing, phase 3 + * + * -------------------------------------------------------------------- + */ + + +/* + * The extent translation table is stored in clusters so we need to + * take special care when mapping a source block number to its + * destination block number. + */ +static __u64 extent_translate(ext2_filsys fs, ext2_extent extent, __u64 old_loc) +{ + __u64 new_block = C2B(ext2fs_extent_translate(extent, B2C(old_loc))); + + if (new_block != 0) + new_block += old_loc & (EXT2FS_CLUSTER_RATIO(fs) - 1); + return new_block; +} + +struct process_block_struct { + ext2_resize_t rfs; + ext2_ino_t ino; + ext2_ino_t old_ino; + struct ext2_inode * inode; + errcode_t error; + int is_dir; + int changed; + int has_extents; +}; + +static int process_block(ext2_filsys fs, blk64_t *block_nr, + e2_blkcnt_t blockcnt, + blk64_t ref_block EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), void *priv_data) +{ + struct process_block_struct *pb; + errcode_t retval; + blk64_t block, new_block; + int ret = 0; + + pb = (struct process_block_struct *) priv_data; + block = *block_nr; + if (pb->rfs->bmap) { + new_block = extent_translate(fs, pb->rfs->bmap, block); + if (new_block) { + *block_nr = new_block; + ret |= BLOCK_CHANGED; + pb->changed = 1; +#ifdef RESIZE2FS_DEBUG + if (pb->rfs->flags & RESIZE_DEBUG_BMOVE) + printf("ino=%u, blockcnt=%lld, %llu->%llu\n", + pb->old_ino, (long long) blockcnt, + (unsigned long long) block, + (unsigned long long) new_block); +#endif + block = new_block; + } + } + + if (pb->is_dir) { + retval = ext2fs_add_dir_block2(fs->dblist, pb->ino, + block, (int) blockcnt); + if (retval) { + pb->error = retval; + ret |= BLOCK_ABORT; + } + } + return ret; +} + +/* + * Progress callback + */ +static errcode_t progress_callback(ext2_filsys fs, + ext2_inode_scan scan EXT2FS_ATTR((unused)), + dgrp_t group, void * priv_data) +{ + ext2_resize_t rfs = (ext2_resize_t) priv_data; + errcode_t retval; + + /* + * This check is to protect against old ext2 libraries. It + * shouldn't be needed against new libraries. + */ + if ((group+1) == 0) + return 0; + + if (rfs->progress) { + io_channel_flush(fs->io); + retval = (rfs->progress)(rfs, E2_RSZ_INODE_SCAN_PASS, + group+1, fs->group_desc_count); + if (retval) + return retval; + } + + return 0; +} + +static errcode_t migrate_ea_block(ext2_resize_t rfs, ext2_ino_t ino, + struct ext2_inode *inode, int *changed) +{ + char *buf = NULL; + blk64_t new_block; + errcode_t err = 0; + + /* No EA block or no remapping? Quit early. */ + if (ext2fs_file_acl_block(rfs->old_fs, inode) == 0 || !rfs->bmap) + return 0; + new_block = extent_translate(rfs->old_fs, rfs->bmap, + ext2fs_file_acl_block(rfs->old_fs, inode)); + if (new_block == 0) + return 0; + + /* Set the new ACL block */ + ext2fs_file_acl_block_set(rfs->old_fs, inode, new_block); + + /* Update checksum */ + if (ext2fs_has_feature_metadata_csum(rfs->new_fs->super)) { + err = ext2fs_get_mem(rfs->old_fs->blocksize, &buf); + if (err) + return err; + rfs->old_fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; + err = ext2fs_read_ext_attr3(rfs->old_fs, new_block, buf, ino); + rfs->old_fs->flags &= ~EXT2_FLAG_IGNORE_CSUM_ERRORS; + if (err) + goto out; + err = ext2fs_write_ext_attr3(rfs->old_fs, new_block, buf, ino); + if (err) + goto out; + } + *changed = 1; + +out: + ext2fs_free_mem(&buf); + return err; +} + +static void quiet_com_err_proc(const char *whoami EXT2FS_ATTR((unused)), + errcode_t code EXT2FS_ATTR((unused)), + const char *fmt EXT2FS_ATTR((unused)), + va_list args EXT2FS_ATTR((unused))) +{ +} + +static int fix_ea_entries(ext2_extent imap, struct ext2_ext_attr_entry *entry, + struct ext2_ext_attr_entry *end, ext2_ino_t last_ino) +{ + int modified = 0; + ext2_ino_t new_ino; + + while (entry < end && !EXT2_EXT_IS_LAST_ENTRY(entry)) { + if (entry->e_value_inum > last_ino) { + new_ino = ext2fs_extent_translate(imap, + entry->e_value_inum); + entry->e_value_inum = new_ino; + modified = 1; + } + entry = EXT2_EXT_ATTR_NEXT(entry); + } + return modified; +} + +static int fix_ea_ibody_entries(ext2_extent imap, + struct ext2_inode_large *inode, int inode_size, + ext2_ino_t last_ino) +{ + struct ext2_ext_attr_entry *start, *end; + __u32 *ea_magic; + + if (inode->i_extra_isize == 0) + return 0; + + ea_magic = (__u32 *)((char *)inode + EXT2_GOOD_OLD_INODE_SIZE + + inode->i_extra_isize); + if (*ea_magic != EXT2_EXT_ATTR_MAGIC) + return 0; + + start = (struct ext2_ext_attr_entry *)(ea_magic + 1); + end = (struct ext2_ext_attr_entry *)((char *)inode + inode_size); + + return fix_ea_entries(imap, start, end, last_ino); +} + +static int fix_ea_block_entries(ext2_extent imap, char *block_buf, + unsigned int blocksize, ext2_ino_t last_ino) +{ + struct ext2_ext_attr_header *header; + struct ext2_ext_attr_entry *start, *end; + + header = (struct ext2_ext_attr_header *)block_buf; + start = (struct ext2_ext_attr_entry *)(header+1); + end = (struct ext2_ext_attr_entry *)(block_buf + blocksize); + + return fix_ea_entries(imap, start, end, last_ino); +} + +/* A simple LRU cache to check recently processed blocks. */ +struct blk_cache { + int cursor; + blk64_t blks[4]; +}; + +#define BLK_IN_CACHE(b,c) ((b) == (c).blks[0] || (b) == (c).blks[1] || \ + (b) == (c).blks[2] || (b) == (c).blks[3]) +#define BLK_ADD_CACHE(b,c) { \ + (c).blks[(c).cursor] = (b); \ + (c).cursor = ((c).cursor + 1) % 4; \ +} + +static errcode_t fix_ea_inode_refs(ext2_resize_t rfs, struct ext2_inode *inode, + char *block_buf, ext2_ino_t last_ino) +{ + ext2_filsys fs = rfs->new_fs; + ext2_inode_scan scan = NULL; + ext2_ino_t ino; + int inode_size = EXT2_INODE_SIZE(fs->super); + blk64_t blk; + int modified; + struct blk_cache blk_cache; + struct ext2_ext_attr_header *header; + errcode_t retval; + + memset(&blk_cache, 0, sizeof(blk_cache)); + + header = (struct ext2_ext_attr_header *)block_buf; + + retval = ext2fs_open_inode_scan(fs, 0, &scan); + if (retval) + goto out; + + while (1) { + retval = ext2fs_get_next_inode_full(scan, &ino, inode, + inode_size); + if (retval) + goto out; + if (!ino) + break; + + if (inode->i_links_count == 0 && ino != EXT2_RESIZE_INO) + continue; /* inode not in use */ + + if (inode_size != EXT2_GOOD_OLD_INODE_SIZE) { + modified = fix_ea_ibody_entries(rfs->imap, + (struct ext2_inode_large *)inode, + inode_size, last_ino); + if (modified) { + retval = ext2fs_write_inode_full(fs, ino, inode, + inode_size); + if (retval) + goto out; + } + } + + blk = ext2fs_file_acl_block(fs, inode); + if (blk && !BLK_IN_CACHE(blk, blk_cache)) { + retval = ext2fs_read_ext_attr3(fs, blk, block_buf, ino); + if (retval) + goto out; + + modified = fix_ea_block_entries(rfs->imap, block_buf, + fs->blocksize, + last_ino); + if (modified) { + retval = ext2fs_write_ext_attr3(fs, blk, + block_buf, ino); + if (retval) + goto out; + /* + * If refcount is greater than 1, we might see + * the same block referenced by other inodes + * later. + */ + if (header->h_refcount > 1) + BLK_ADD_CACHE(blk, blk_cache); + } + } + } + retval = 0; +out: + if (scan) + ext2fs_close_inode_scan(scan); + return retval; + +} +static errcode_t inode_scan_and_fix(ext2_resize_t rfs) +{ + struct process_block_struct pb; + ext2_ino_t ino, new_inode; + struct ext2_inode *inode = NULL; + ext2_inode_scan scan = NULL; + errcode_t retval; + char *block_buf = 0; + ext2_ino_t start_to_move; + int inode_size; + int update_ea_inode_refs = 0; + + if ((rfs->old_fs->group_desc_count <= + rfs->new_fs->group_desc_count) && + !rfs->bmap) + return 0; + + set_com_err_hook(quiet_com_err_proc); + + retval = ext2fs_open_inode_scan(rfs->old_fs, 0, &scan); + if (retval) goto errout; + + retval = ext2fs_init_dblist(rfs->old_fs, 0); + if (retval) goto errout; + retval = ext2fs_get_array(rfs->old_fs->blocksize, 3, &block_buf); + if (retval) goto errout; + + start_to_move = (rfs->new_fs->group_desc_count * + rfs->new_fs->super->s_inodes_per_group); + + if (rfs->progress) { + retval = (rfs->progress)(rfs, E2_RSZ_INODE_SCAN_PASS, + 0, rfs->old_fs->group_desc_count); + if (retval) + goto errout; + } + ext2fs_set_inode_callback(scan, progress_callback, (void *) rfs); + pb.rfs = rfs; + pb.inode = inode; + pb.error = 0; + new_inode = EXT2_FIRST_INODE(rfs->new_fs->super); + inode_size = EXT2_INODE_SIZE(rfs->new_fs->super); + inode = malloc(inode_size); + if (!inode) { + retval = ENOMEM; + goto errout; + } + /* + * First, copy all of the inodes that need to be moved + * elsewhere in the inode table + */ + while (1) { + retval = ext2fs_get_next_inode_full(scan, &ino, inode, inode_size); + if (retval) goto errout; + if (!ino) + break; + + if (inode->i_links_count == 0 && ino != EXT2_RESIZE_INO) + continue; /* inode not in use */ + + pb.is_dir = LINUX_S_ISDIR(inode->i_mode); + pb.changed = 0; + + /* Remap EA block */ + retval = migrate_ea_block(rfs, ino, inode, &pb.changed); + if (retval) + goto errout; + + new_inode = ino; + if (ino <= start_to_move) + goto remap_blocks; /* Don't need to move inode. */ + + /* + * Find a new inode. Now that extents and directory blocks + * are tied to the inode number through the checksum, we must + * set up the new inode before we start rewriting blocks. + */ + retval = ext2fs_new_inode(rfs->new_fs, 0, 0, 0, &new_inode); + if (retval) + goto errout; + + ext2fs_inode_alloc_stats2(rfs->new_fs, new_inode, +1, + pb.is_dir); + /* + * i_ctime field in xattr inodes contain a portion of the ref + * count, do not overwrite. + */ + if (inode->i_flags & EXT4_EA_INODE_FL) + update_ea_inode_refs = 1; + else + inode->i_ctime = rfs->old_fs->now ? + rfs->old_fs->now : time(0); + + retval = ext2fs_write_inode_full(rfs->old_fs, new_inode, + inode, inode_size); + if (retval) + goto errout; + pb.changed = 0; + +#ifdef RESIZE2FS_DEBUG + if (rfs->flags & RESIZE_DEBUG_INODEMAP) + printf("Inode moved %u->%u\n", ino, new_inode); +#endif + if (!rfs->imap) { + retval = ext2fs_create_extent_table(&rfs->imap, 0); + if (retval) + goto errout; + } + ext2fs_add_extent_entry(rfs->imap, ino, new_inode); + +remap_blocks: + if (pb.changed) + retval = ext2fs_write_inode_full(rfs->old_fs, + new_inode, + inode, inode_size); + if (retval) + goto errout; + + /* + * Update inodes to point to new blocks; schedule directory + * blocks for inode remapping. Need to write out dir blocks + * with new inode numbers if we have metadata_csum enabled. + */ + rfs->old_fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; + if (ext2fs_inode_has_valid_blocks2(rfs->old_fs, inode) && + (rfs->bmap || pb.is_dir)) { + pb.ino = new_inode; + pb.old_ino = ino; + pb.has_extents = inode->i_flags & EXT4_EXTENTS_FL; + retval = ext2fs_block_iterate3(rfs->old_fs, + new_inode, 0, block_buf, + process_block, &pb); + if (retval) + goto errout; + if (pb.error) { + retval = pb.error; + goto errout; + } + } else if ((inode->i_flags & EXT4_INLINE_DATA_FL) && + (rfs->bmap || pb.is_dir)) { + /* inline data dir; update it too */ + retval = ext2fs_add_dir_block2(rfs->old_fs->dblist, + new_inode, 0, 0); + if (retval) + goto errout; + } + + /* Fix up extent block checksums with the new inode number */ + if (ext2fs_has_feature_metadata_csum(rfs->old_fs->super) && + (inode->i_flags & EXT4_EXTENTS_FL)) { + retval = ext2fs_fix_extents_checksums(rfs->old_fs, + new_inode, NULL); + if (retval) + goto errout; + } + } + + if (update_ea_inode_refs && + ext2fs_has_feature_ea_inode(rfs->new_fs->super)) { + retval = fix_ea_inode_refs(rfs, inode, block_buf, + start_to_move); + if (retval) + goto errout; + } + io_channel_flush(rfs->old_fs->io); + +errout: + reset_com_err_hook(); + rfs->old_fs->flags &= ~EXT2_FLAG_IGNORE_CSUM_ERRORS; + if (rfs->bmap) { + ext2fs_free_extent_table(rfs->bmap); + rfs->bmap = 0; + } + if (scan) + ext2fs_close_inode_scan(scan); + if (block_buf) + ext2fs_free_mem(&block_buf); + free(inode); + return retval; +} + +/* -------------------------------------------------------------------- + * + * Resize processing, phase 4. + * + * -------------------------------------------------------------------- + */ + +struct istruct { + ext2_resize_t rfs; + errcode_t err; + unsigned int max_dirs; + unsigned int num; +}; + +static int check_and_change_inodes(ext2_ino_t dir, + int entry EXT2FS_ATTR((unused)), + struct ext2_dir_entry *dirent, int offset, + int blocksize EXT2FS_ATTR((unused)), + char *buf EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct istruct *is = (struct istruct *) priv_data; + struct ext2_inode inode; + ext2_ino_t new_inode; + errcode_t retval; + int ret = 0; + + if (is->rfs->progress && offset == 0) { + io_channel_flush(is->rfs->old_fs->io); + is->err = (is->rfs->progress)(is->rfs, + E2_RSZ_INODE_REF_UPD_PASS, + ++is->num, is->max_dirs); + if (is->err) + return DIRENT_ABORT; + } + + /* + * If we have checksums enabled and the inode wasn't present in the + * old fs, then we must rewrite all dir blocks with new checksums. + */ + if (ext2fs_has_feature_metadata_csum(is->rfs->old_fs->super) && + !ext2fs_test_inode_bitmap2(is->rfs->old_fs->inode_map, dir)) + ret |= DIRENT_CHANGED; + + if (!dirent->inode) + return ret; + + new_inode = ext2fs_extent_translate(is->rfs->imap, dirent->inode); + + if (!new_inode) + return ret; +#ifdef RESIZE2FS_DEBUG + if (is->rfs->flags & RESIZE_DEBUG_INODEMAP) + printf("Inode translate (dir=%u, name=%.*s, %u->%u)\n", + dir, ext2fs_dirent_name_len(dirent), dirent->name, + dirent->inode, new_inode); +#endif + + dirent->inode = new_inode; + + /* Update the directory mtime and ctime */ + retval = ext2fs_read_inode(is->rfs->old_fs, dir, &inode); + if (retval == 0) { + inode.i_mtime = inode.i_ctime = is->rfs->old_fs->now ? + is->rfs->old_fs->now : time(0); + is->err = ext2fs_write_inode(is->rfs->old_fs, dir, &inode); + if (is->err) + return ret | DIRENT_ABORT; + } + + return ret | DIRENT_CHANGED; +} + +static errcode_t inode_ref_fix(ext2_resize_t rfs) +{ + errcode_t retval; + struct istruct is; + + if (!rfs->imap) + return 0; + + /* + * Now, we iterate over all of the directories to update the + * inode references + */ + is.num = 0; + is.max_dirs = ext2fs_dblist_count2(rfs->old_fs->dblist); + is.rfs = rfs; + is.err = 0; + + if (rfs->progress) { + retval = (rfs->progress)(rfs, E2_RSZ_INODE_REF_UPD_PASS, + 0, is.max_dirs); + if (retval) + goto errout; + } + + rfs->old_fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; + retval = ext2fs_dblist_dir_iterate(rfs->old_fs->dblist, + DIRENT_FLAG_INCLUDE_EMPTY, 0, + check_and_change_inodes, &is); + rfs->old_fs->flags &= ~EXT2_FLAG_IGNORE_CSUM_ERRORS; + if (retval) + goto errout; + if (is.err) { + retval = is.err; + goto errout; + } + + if (rfs->progress && (is.num < is.max_dirs)) + (rfs->progress)(rfs, E2_RSZ_INODE_REF_UPD_PASS, + is.max_dirs, is.max_dirs); + +errout: + ext2fs_free_extent_table(rfs->imap); + rfs->imap = 0; + return retval; +} + + +/* -------------------------------------------------------------------- + * + * Resize processing, phase 5. + * + * In this phase we actually move the inode table around, and then + * update the summary statistics. This is scary, since aborting here + * will potentially scramble the filesystem. (We are moving the + * inode tables around in place, and so the potential for lost data, + * or at the very least scrambling the mapping between filenames and + * inode numbers is very high in case of a power failure here.) + * -------------------------------------------------------------------- + */ + + +/* + * A very scary routine --- this one moves the inode table around!!! + * + * After this you have to use the rfs->new_fs file handle to read and + * write inodes. + */ +static errcode_t move_itables(ext2_resize_t rfs) +{ + int n, num, size; + long long diff; + dgrp_t i, max_groups; + ext2_filsys fs = rfs->new_fs; + char *cp; + blk64_t old_blk, new_blk, blk, cluster_freed; + errcode_t retval; + int to_move, moved; + unsigned int j; + ext2fs_block_bitmap new_bmap = NULL; + + max_groups = fs->group_desc_count; + if (max_groups > rfs->old_fs->group_desc_count) + max_groups = rfs->old_fs->group_desc_count; + + size = fs->blocksize * fs->inode_blocks_per_group; + if (!rfs->itable_buf) { + retval = ext2fs_get_mem(size, &rfs->itable_buf); + if (retval) + return retval; + } + + if (EXT2FS_CLUSTER_RATIO(fs) > 1) { + retval = ext2fs_allocate_block_bitmap(fs, _("new meta blocks"), + &new_bmap); + if (retval) + return retval; + + retval = mark_table_blocks(fs, new_bmap); + if (retval) + goto errout; + } + + /* + * Figure out how many inode tables we need to move + */ + to_move = moved = 0; + for (i=0; i < max_groups; i++) + if (ext2fs_inode_table_loc(rfs->old_fs, i) != + ext2fs_inode_table_loc(fs, i)) + to_move++; + + if (to_move == 0) { + retval = 0; + goto errout; + } + + if (rfs->progress) { + retval = rfs->progress(rfs, E2_RSZ_MOVE_ITABLE_PASS, + 0, to_move); + if (retval) + goto errout; + } + + rfs->old_fs->flags |= EXT2_FLAG_MASTER_SB_ONLY; + + for (i=0; i < max_groups; i++) { + old_blk = ext2fs_inode_table_loc(rfs->old_fs, i); + new_blk = ext2fs_inode_table_loc(fs, i); + diff = new_blk - old_blk; + +#ifdef RESIZE2FS_DEBUG + if (rfs->flags & RESIZE_DEBUG_ITABLEMOVE) + printf("Itable move group %d block %llu->%llu (diff %lld)\n", + i, (unsigned long long) old_blk, + (unsigned long long) new_blk, diff); +#endif + + if (!diff) + continue; + if (diff < 0) + diff = 0; + + retval = io_channel_read_blk64(fs->io, old_blk, + fs->inode_blocks_per_group, + rfs->itable_buf); + if (retval) + goto errout; + /* + * The end of the inode table segment often contains + * all zeros, and we're often only moving the inode + * table down a block or two. If so, we can optimize + * things by not rewriting blocks that we know to be zero + * already. + */ + for (cp = rfs->itable_buf+size-1, n=0; n < size; n++, cp--) + if (*cp) + break; + n = n >> EXT2_BLOCK_SIZE_BITS(fs->super); +#ifdef RESIZE2FS_DEBUG + if (rfs->flags & RESIZE_DEBUG_ITABLEMOVE) + printf("%d blocks of zeros...\n", n); +#endif + num = fs->inode_blocks_per_group; + if (n > diff) + num -= n; + + retval = io_channel_write_blk64(fs->io, new_blk, + num, rfs->itable_buf); + if (retval) { + io_channel_write_blk64(fs->io, old_blk, + num, rfs->itable_buf); + goto errout; + } + if (n > diff) { + retval = io_channel_write_blk64(fs->io, + old_blk + fs->inode_blocks_per_group, + diff, (rfs->itable_buf + + (fs->inode_blocks_per_group - diff) * + fs->blocksize)); + if (retval) + goto errout; + } + + for (blk = ext2fs_inode_table_loc(rfs->old_fs, i), j=0; + j < fs->inode_blocks_per_group;) { + if (new_bmap == NULL || + !ext2fs_test_block_bitmap2(new_bmap, blk)) { + ext2fs_block_alloc_stats2(fs, blk, -1); + cluster_freed = EXT2FS_CLUSTER_RATIO(fs) - + (blk & EXT2FS_CLUSTER_MASK(fs)); + blk += cluster_freed; + j += cluster_freed; + continue; + } + blk++; + j++; + } + + ext2fs_inode_table_loc_set(rfs->old_fs, i, new_blk); + ext2fs_group_desc_csum_set(rfs->old_fs, i); + ext2fs_mark_super_dirty(rfs->old_fs); + ext2fs_flush(rfs->old_fs); + + if (rfs->progress) { + retval = rfs->progress(rfs, E2_RSZ_MOVE_ITABLE_PASS, + ++moved, to_move); + if (retval) + goto errout; + } + } + mark_table_blocks(fs, fs->block_map); + ext2fs_flush(fs); +#ifdef RESIZE2FS_DEBUG + if (rfs->flags & RESIZE_DEBUG_ITABLEMOVE) + printf("Inode table move finished.\n"); +#endif + retval = 0; + +errout: + if (new_bmap) + ext2fs_free_block_bitmap(new_bmap); + return retval; +} + +/* + * This function is used when expanding a file system. It frees the + * superblock and block group descriptor blocks from the block group + * which is no longer the last block group. + */ +static errcode_t clear_sparse_super2_last_group(ext2_resize_t rfs) +{ + ext2_filsys fs = rfs->new_fs; + ext2_filsys old_fs = rfs->old_fs; + errcode_t retval; + dgrp_t old_last_bg = rfs->old_fs->group_desc_count - 1; + dgrp_t last_bg = fs->group_desc_count - 1; + blk64_t sb, old_desc; + blk_t num; + + if (!ext2fs_has_feature_sparse_super2(fs->super)) + return 0; + + if (last_bg <= old_last_bg) + return 0; + + if (fs->super->s_backup_bgs[0] == old_fs->super->s_backup_bgs[0] && + fs->super->s_backup_bgs[1] == old_fs->super->s_backup_bgs[1]) + return 0; + + if (old_fs->super->s_backup_bgs[0] != old_last_bg && + old_fs->super->s_backup_bgs[1] != old_last_bg) + return 0; + + if (fs->super->s_backup_bgs[0] == old_last_bg || + fs->super->s_backup_bgs[1] == old_last_bg) + return 0; + + if (old_last_bg == 0) + return 0; + + retval = ext2fs_super_and_bgd_loc2(rfs->old_fs, old_last_bg, + &sb, &old_desc, NULL, &num); + if (retval) + return retval; + + if (sb) + ext2fs_unmark_block_bitmap2(fs->block_map, sb); + if (old_desc) + ext2fs_unmark_block_bitmap_range2(fs->block_map, old_desc, num); + return 0; +} + +/* + * This function is used when shrinking a file system. We need to + * utilize blocks from what will be the new last block group for the + * backup superblock and block group descriptor blocks. + * Unfortunately, those blocks may be used by other files or fs + * metadata blocks. We need to mark them as being in use. + */ +static errcode_t reserve_sparse_super2_last_group(ext2_resize_t rfs, + ext2fs_block_bitmap meta_bmap) +{ + ext2_filsys fs = rfs->new_fs; + ext2_filsys old_fs = rfs->old_fs; + errcode_t retval; + dgrp_t old_last_bg = rfs->old_fs->group_desc_count - 1; + dgrp_t last_bg = fs->group_desc_count - 1; + dgrp_t g; + blk64_t blk, sb, old_desc; + blk_t i, num; + int realloc = 0; + + if (!ext2fs_has_feature_sparse_super2(fs->super)) + return 0; + + if (last_bg >= old_last_bg) + return 0; + + if (fs->super->s_backup_bgs[0] == old_fs->super->s_backup_bgs[0] && + fs->super->s_backup_bgs[1] == old_fs->super->s_backup_bgs[1]) + return 0; + + if (fs->super->s_backup_bgs[0] != last_bg && + fs->super->s_backup_bgs[1] != last_bg) + return 0; + + if (old_fs->super->s_backup_bgs[0] == last_bg || + old_fs->super->s_backup_bgs[1] == last_bg) + return 0; + + retval = ext2fs_super_and_bgd_loc2(rfs->new_fs, last_bg, + &sb, &old_desc, NULL, &num); + if (retval) + return retval; + + if (last_bg && !sb) { + fputs(_("Should never happen! No sb in last super_sparse bg?\n"), + stderr); + exit(1); + } + if (old_desc && old_desc != sb+1) { + fputs(_("Should never happen! Unexpected old_desc in " + "super_sparse bg?\n"), + stderr); + exit(1); + } + num = (old_desc) ? num : 1; + + /* Reserve the backup blocks */ + ext2fs_mark_block_bitmap_range2(fs->block_map, sb, num); + + for (g = 0; g < fs->group_desc_count; g++) { + blk64_t mb; + + mb = ext2fs_block_bitmap_loc(fs, g); + if ((mb >= sb) && (mb < sb + num)) { + ext2fs_block_bitmap_loc_set(fs, g, 0); + realloc = 1; + } + mb = ext2fs_inode_bitmap_loc(fs, g); + if ((mb >= sb) && (mb < sb + num)) { + ext2fs_inode_bitmap_loc_set(fs, g, 0); + realloc = 1; + } + mb = ext2fs_inode_table_loc(fs, g); + if ((mb < sb + num) && + (sb < mb + fs->inode_blocks_per_group)) { + ext2fs_inode_table_loc_set(fs, g, 0); + realloc = 1; + } + if (realloc) { + retval = ext2fs_allocate_group_table(fs, g, 0); + if (retval) + return retval; + } + } + + for (blk = sb, i = 0; i < num; blk++, i++) { + if (ext2fs_test_block_bitmap2(old_fs->block_map, blk) && + !ext2fs_test_block_bitmap2(meta_bmap, blk)) { + ext2fs_mark_block_bitmap2(rfs->move_blocks, blk); + rfs->needed_blocks++; + } + ext2fs_mark_block_bitmap2(rfs->reserve_blocks, blk); + } + return 0; +} + +/* + * Fix the resize inode + */ +static errcode_t fix_resize_inode(ext2_filsys fs) +{ + struct ext2_inode inode; + errcode_t retval; + + if (!ext2fs_has_feature_resize_inode(fs->super)) + return 0; + + retval = ext2fs_read_inode(fs, EXT2_RESIZE_INO, &inode); + if (retval) goto errout; + + ext2fs_iblk_set(fs, &inode, 1); + + retval = ext2fs_write_inode(fs, EXT2_RESIZE_INO, &inode); + if (retval) goto errout; + + if (!inode.i_block[EXT2_DIND_BLOCK]) { + /* + * Avoid zeroing out block #0; that's rude. This + * should never happen anyway since the filesystem + * should be fsck'ed and we assume it is consistent. + */ + fprintf(stderr, "%s", + _("Should never happen: resize inode corrupt!\n")); + exit(1); + } + + retval = ext2fs_zero_blocks2(fs, inode.i_block[EXT2_DIND_BLOCK], 1, + NULL, NULL); + if (retval) + goto errout; + + retval = ext2fs_create_resize_inode(fs); + if (retval) + goto errout; + +errout: + return retval; +} + +/* + * Finally, recalculate the summary information + */ +static errcode_t resize2fs_calculate_summary_stats(ext2_filsys fs) +{ + errcode_t retval; + blk64_t blk = fs->super->s_first_data_block; + ext2_ino_t ino; + unsigned int n, group, count; + blk64_t total_clusters_free = 0; + int total_inodes_free = 0; + int group_free = 0; + int uninit = 0; + char *bitmap_buf; + + /* + * First calculate the block statistics + */ + bitmap_buf = malloc(fs->blocksize); + if (!bitmap_buf) + return ENOMEM; + for (group = 0; group < fs->group_desc_count; + group++) { + retval = ext2fs_get_block_bitmap_range2(fs->block_map, + B2C(blk), fs->super->s_clusters_per_group, bitmap_buf); + if (retval) { + free(bitmap_buf); + return retval; + } + n = ext2fs_bitcount(bitmap_buf, + fs->super->s_clusters_per_group / 8); + group_free = fs->super->s_clusters_per_group - n; + total_clusters_free += group_free; + ext2fs_bg_free_blocks_count_set(fs, group, group_free); + ext2fs_group_desc_csum_set(fs, group); + blk += fs->super->s_blocks_per_group; + } + free(bitmap_buf); + ext2fs_free_blocks_count_set(fs->super, C2B(total_clusters_free)); + + /* + * Next, calculate the inode statistics + */ + group_free = 0; + count = 0; + group = 0; + + /* Protect loop from wrap-around if s_inodes_count maxed */ + uninit = ext2fs_bg_flags_test(fs, group, EXT2_BG_INODE_UNINIT); + for (ino = 1; ino <= fs->super->s_inodes_count && ino > 0; ino++) { + if (uninit || + !ext2fs_fast_test_inode_bitmap2(fs->inode_map, ino)) { + group_free++; + total_inodes_free++; + } + count++; + if ((count == fs->super->s_inodes_per_group) || + (ino == fs->super->s_inodes_count)) { + ext2fs_bg_free_inodes_count_set(fs, group, group_free); + ext2fs_group_desc_csum_set(fs, group); + group++; + if (group >= fs->group_desc_count) + break; + count = 0; + group_free = 0; + uninit = ext2fs_bg_flags_test(fs, group, EXT2_BG_INODE_UNINIT); + } + } + fs->super->s_free_inodes_count = total_inodes_free; + ext2fs_mark_super_dirty(fs); + return 0; +} + +/* + * Journal may have been relocated; update the backup journal blocks + * in the superblock. + */ +static errcode_t fix_sb_journal_backup(ext2_filsys fs) +{ + errcode_t retval; + struct ext2_inode inode; + + if (!ext2fs_has_feature_journal(fs->super)) + return 0; + + /* External journal? Nothing to do. */ + if (fs->super->s_journal_dev && !fs->super->s_journal_inum) + return 0; + + retval = ext2fs_read_inode(fs, fs->super->s_journal_inum, &inode); + if (retval) + return retval; + memcpy(fs->super->s_jnl_blocks, inode.i_block, EXT2_N_BLOCKS*4); + fs->super->s_jnl_blocks[15] = inode.i_size_high; + fs->super->s_jnl_blocks[16] = inode.i_size; + fs->super->s_jnl_backup_type = EXT3_JNL_BACKUP_BLOCKS; + ext2fs_mark_super_dirty(fs); + return 0; +} + +static int calc_group_overhead(ext2_filsys fs, blk64_t grp, + int old_desc_blocks) +{ + blk64_t super_blk, old_desc_blk, new_desc_blk; + int overhead; + + /* inode table blocks plus allocation bitmaps */ + overhead = fs->inode_blocks_per_group + 2; + + ext2fs_super_and_bgd_loc2(fs, grp, &super_blk, + &old_desc_blk, &new_desc_blk, 0); + if ((grp == 0) || super_blk) + overhead++; + if (old_desc_blk) + overhead += old_desc_blocks; + else if (new_desc_blk) + overhead++; + return overhead; +} + + +/* + * calculate the minimum number of blocks the given fs can be resized to + */ +blk64_t calculate_minimum_resize_size(ext2_filsys fs, int flags) +{ + ext2_ino_t inode_count; + dgrp_t groups, flex_groups; + blk64_t blks_needed, data_blocks; + blk64_t grp, data_needed, last_start; + blk64_t overhead = 0; + int old_desc_blocks; + unsigned flexbg_size = 1U << fs->super->s_log_groups_per_flex; + + /* + * first figure out how many group descriptors we need to + * handle the number of inodes we have + */ + inode_count = fs->super->s_inodes_count - + fs->super->s_free_inodes_count; + blks_needed = ext2fs_div_ceil(inode_count, + fs->super->s_inodes_per_group) * + (blk64_t) EXT2_BLOCKS_PER_GROUP(fs->super); + groups = ext2fs_div64_ceil(blks_needed, + EXT2_BLOCKS_PER_GROUP(fs->super)); +#ifdef RESIZE2FS_DEBUG + if (flags & RESIZE_DEBUG_MIN_CALC) + printf("fs has %d inodes, %d groups required.\n", + inode_count, groups); +#endif + + /* + * number of old-style block group descriptor blocks + */ + if (ext2fs_has_feature_meta_bg(fs->super)) + old_desc_blocks = fs->super->s_first_meta_bg; + else + old_desc_blocks = fs->desc_blocks + + fs->super->s_reserved_gdt_blocks; + + /* calculate how many blocks are needed for data */ + data_needed = ext2fs_blocks_count(fs->super); + for (grp = 0; grp < fs->group_desc_count; grp++) { + __u32 n = ext2fs_bg_free_blocks_count(fs, grp); + + if (n > EXT2_BLOCKS_PER_GROUP(fs->super)) + n = EXT2_BLOCKS_PER_GROUP(fs->super); + n += calc_group_overhead(fs, grp, old_desc_blocks); + if (data_needed < n) { + if (flags & RESIZE_DEBUG_MIN_CALC) + printf("file system appears inconsistent?!?\n"); + return ext2fs_blocks_count(fs->super); + } + data_needed -= n; + } +#ifdef RESIZE2FS_DEBUG + if (flags & RESIZE_DEBUG_MIN_CALC) + printf("fs requires %llu data blocks.\n", + (unsigned long long) data_needed); +#endif + + /* + * For ext4 we need to allow for up to a flex_bg worth of + * inode tables of slack space so the resize operation can be + * guaranteed to finish. + */ + flex_groups = groups; + if (ext2fs_has_feature_flex_bg(fs->super)) { + dgrp_t remainder = groups & (flexbg_size - 1); + + flex_groups += flexbg_size - remainder; + if (flex_groups > fs->group_desc_count) + flex_groups = fs->group_desc_count; + } + + /* + * figure out how many data blocks we have given the number of groups + * we need for our inodes + */ + data_blocks = EXT2_GROUPS_TO_BLOCKS(fs->super, groups); + last_start = 0; + for (grp = 0; grp < flex_groups; grp++) { + overhead = calc_group_overhead(fs, grp, old_desc_blocks); + + /* + * we want to keep track of how much data we can store in + * the groups leading up to the last group so we can determine + * how big the last group needs to be + */ + if (grp < (groups - 1)) + last_start += EXT2_BLOCKS_PER_GROUP(fs->super) - + overhead; + + if (data_blocks > overhead) + data_blocks -= overhead; + else + data_blocks = 0; + } +#ifdef RESIZE2FS_DEBUG + if (flags & RESIZE_DEBUG_MIN_CALC) + printf("With %d group(s), we have %llu blocks available.\n", + groups, (unsigned long long) data_blocks); +#endif + + /* + * if we need more group descriptors in order to accommodate our data + * then we need to add them here + */ + blks_needed = data_needed; + while (blks_needed > data_blocks) { + blk64_t remainder = blks_needed - data_blocks; + dgrp_t extra_grps; + + /* figure out how many more groups we need for the data */ + extra_grps = ext2fs_div64_ceil(remainder, + EXT2_BLOCKS_PER_GROUP(fs->super)); + + data_blocks += EXT2_GROUPS_TO_BLOCKS(fs->super, extra_grps); + + /* ok we have to account for the last group */ + overhead = calc_group_overhead(fs, groups-1, old_desc_blocks); + last_start += EXT2_BLOCKS_PER_GROUP(fs->super) - overhead; + + grp = flex_groups; + groups += extra_grps; + if (!ext2fs_has_feature_flex_bg(fs->super)) + flex_groups = groups; + else if (groups > flex_groups) { + dgrp_t r = groups & (flexbg_size - 1); + + flex_groups = groups + flexbg_size - r; + if (flex_groups > fs->group_desc_count) + flex_groups = fs->group_desc_count; + } + + for (; grp < flex_groups; grp++) { + overhead = calc_group_overhead(fs, grp, + old_desc_blocks); + + /* + * again, we need to see how much data we cram into + * all of the groups leading up to the last group + */ + if (grp < groups - 1) + last_start += EXT2_BLOCKS_PER_GROUP(fs->super) + - overhead; + + data_blocks -= overhead; + } + +#ifdef RESIZE2FS_DEBUG + if (flags & RESIZE_DEBUG_MIN_CALC) + printf("Added %d extra group(s), " + "blks_needed %llu, data_blocks %llu, " + "last_start %llu\n", extra_grps, + (unsigned long long) blks_needed, + (unsigned long long) data_blocks, + (unsigned long long) last_start); +#endif + } + + /* now for the fun voodoo */ + grp = groups - 1; + if (ext2fs_has_feature_flex_bg(fs->super) && + (grp & ~(flexbg_size - 1)) == 0) + grp = grp & ~(flexbg_size - 1); + overhead = 0; + for (; grp < flex_groups; grp++) + overhead += calc_group_overhead(fs, grp, old_desc_blocks); + +#ifdef RESIZE2FS_DEBUG + if (flags & RESIZE_DEBUG_MIN_CALC) + printf("Last group's overhead is %llu\n", + (unsigned long long) overhead); +#endif + + /* + * if this is the case then the last group is going to have data in it + * so we need to adjust the size of the last group accordingly + */ + if (last_start < blks_needed) { + blk64_t remainder = blks_needed - last_start; + +#ifdef RESIZE2FS_DEBUG + if (flags & RESIZE_DEBUG_MIN_CALC) + printf("Need %llu data blocks in last group\n", + (unsigned long long) remainder); +#endif + /* + * 50 is a magic number that mkfs/resize uses to see if its + * even worth making/resizing the fs. basically you need to + * have at least 50 blocks in addition to the blocks needed + * for the metadata in the last group + */ + if (remainder > 50) + overhead += remainder; + else + overhead += 50; + } else + overhead += 50; + + overhead += fs->super->s_first_data_block; +#ifdef RESIZE2FS_DEBUG + if (flags & RESIZE_DEBUG_MIN_CALC) + printf("Final size of last group is %llu\n", + (unsigned long long) overhead); +#endif + + /* Add extra slack for bigalloc file systems */ + if (EXT2FS_CLUSTER_RATIO(fs) > 1) + overhead += EXT2FS_CLUSTER_RATIO(fs) * 2; + + /* + * since our last group doesn't have to be BLOCKS_PER_GROUP + * large, we only do groups-1, and then add the number of + * blocks needed to handle the group descriptor metadata+data + * that we need + */ + blks_needed = EXT2_GROUPS_TO_BLOCKS(fs->super, groups - 1); + blks_needed += overhead; + + /* + * Make sure blks_needed covers the end of the inode table in + * the last block group. + */ + overhead = ext2fs_inode_table_loc(fs, groups-1) + + fs->inode_blocks_per_group; + if (blks_needed < overhead) + blks_needed = overhead; + +#ifdef RESIZE2FS_DEBUG + if (flags & RESIZE_DEBUG_MIN_CALC) + printf("Estimated blocks needed: %llu\n", + (unsigned long long) blks_needed); +#endif + + /* + * If at this point we've already added up more "needed" than + * the current size, just return current size as minimum. + */ + if (blks_needed >= ext2fs_blocks_count(fs->super)) + return ext2fs_blocks_count(fs->super); + /* + * We need to reserve a few extra blocks if extents are + * enabled, in case we need to grow the extent tree. The more + * we shrink the file system, the more space we need. + * + * The absolute worst case is every single data block is in + * the part of the file system that needs to be evacuated, + * with each data block needs to be in its own extent, and + * with each inode needing at least one extent block. + */ + if (ext2fs_has_feature_extents(fs->super)) { + blk64_t safe_margin = (ext2fs_blocks_count(fs->super) - + blks_needed)/500; + unsigned int exts_per_blk = (fs->blocksize / + sizeof(struct ext3_extent)) - 1; + blk64_t worst_case = ((data_needed + exts_per_blk - 1) / + exts_per_blk); + + if (worst_case < inode_count) + worst_case = inode_count; + + if (safe_margin > worst_case) + safe_margin = worst_case; + +#ifdef RESIZE2FS_DEBUG + if (flags & RESIZE_DEBUG_MIN_CALC) + printf("Extents safety margin: %llu\n", + (unsigned long long) safe_margin); +#endif + blks_needed += safe_margin; + } + + return blks_needed; +} |