resize2fs: Fix up to be 64-bit block number safe

Signed-off-by: Valerie Aurora Henson <vaurora@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>

diff --git a/resize/extent.c b/resize/extent.c
index 2ed7591d1675bd3bce50d31725f368b5b2452297..0da8df6d182c8665da238777ff47b954ae9d4682 100644 (file)
--- a/resize/extent.c
+++ b/resize/extent.c
@@ -19,22 +19,22 @@
 #include "resize2fs.h"
 
 struct ext2_extent_entry {
-       __u32   old_loc, new_loc;
-       int     size;
+       __u64   old_loc, new_loc;
+       __u64   size;
 };
 
 struct _ext2_extent {
        struct ext2_extent_entry *list;
-       int     cursor;
-       int     size;
-       int     num;
-       int     sorted;
+       __u64   cursor;
+       __u64   size;
+       __u64   num;
+       __u64   sorted;
 };
 
 /*
  * Create an extent table
  */
-errcode_t ext2fs_create_extent_table(ext2_extent *ret_extent, int size)
+errcode_t ext2fs_create_extent_table(ext2_extent *ret_extent, __u64 size)
 {
        ext2_extent     extent;
        errcode_t       retval;
@@ -77,12 +77,12 @@ void ext2fs_free_extent_table(ext2_extent extent)
 /*
  * Add an entry to the extent table
  */
-errcode_t ext2fs_add_extent_entry(ext2_extent extent, __u32 old_loc, __u32 new_loc)
+errcode_t ext2fs_add_extent_entry(ext2_extent extent, __u64 old_loc, __u64 new_loc)
 {
        struct  ext2_extent_entry       *ent;
        errcode_t                       retval;
-       int                             newsize;
-       int                             curr;
+       __u64                           newsize;
+       __u64                           curr;
 
        if (extent->num >= extent->size) {
                newsize = extent->size + 100;
@@ -139,10 +139,10 @@ static EXT2_QSORT_TYPE extent_cmp(const void *a, const void *b)
  * Given an inode map and inode number, look up the old inode number
  * and return the new inode number.
  */
-__u32 ext2fs_extent_translate(ext2_extent extent, __u32 old_loc)
+__u64 ext2fs_extent_translate(ext2_extent extent, __u64 old_loc)
 {
-       int     low, high, mid;
-       __u32   lowval, highval;
+       __s64   low, high, mid;
+       __u64   lowval, highval;
        float   range;
 
        if (!extent->sorted) {
@@ -170,7 +170,7 @@ __u32 ext2fs_extent_translate(ext2_extent extent, __u32 old_loc)
                        else
                                range = ((float) (old_loc - lowval)) /
                                        (highval - lowval);
-                       mid = low + ((int) (range * (high-low)));
+                       mid = low + ((__u64) (range * (high-low)));
                }
 #endif
                if ((old_loc >= extent->list[mid].old_loc) &&
@@ -190,14 +190,14 @@ __u32 ext2fs_extent_translate(ext2_extent extent, __u32 old_loc)
  */
 void ext2fs_extent_dump(ext2_extent extent, FILE *out)
 {
-       int     i;
+       __u64   i;
        struct ext2_extent_entry *ent;
 
        fputs(_("# Extent dump:\n"), out);
-       fprintf(out, _("#\tNum=%d, Size=%d, Cursor=%d, Sorted=%d\n"),
+       fprintf(out, _("#\tNum=%llu, Size=%llu, Cursor=%llu, Sorted=%llu\n"),
               extent->num, extent->size, extent->cursor, extent->sorted);
        for (i=0, ent=extent->list; i < extent->num; i++, ent++) {
-               fprintf(out, _("#\t\t %u -> %u (%d)\n"), ent->old_loc,
+               fprintf(out, _("#\t\t %llu -> %llu (%llu)\n"), ent->old_loc,
                        ent->new_loc, ent->size);
        }
 }
@@ -205,8 +205,8 @@ void ext2fs_extent_dump(ext2_extent extent, FILE *out)
 /*
  * Iterate over the contents of the extent table
  */
-errcode_t ext2fs_iterate_extent(ext2_extent extent, __u32 *old_loc,
-                               __u32 *new_loc, int *size)
+errcode_t ext2fs_iterate_extent(ext2_extent extent, __u64 *old_loc,
+                               __u64 *new_loc, __u64 *size)
 {
        struct ext2_extent_entry *ent;
 

diff --git a/resize/main.c b/resize/main.c
index f5ffb0f6690871c66a2ef9e40a278a9620510740..7c4f4ddad993461de672c37abf1a16b6739c90a9 100644 (file)
--- a/resize/main.c
+++ b/resize/main.c
@@ -158,9 +158,9 @@ int main (int argc, char ** argv)
        int             force_min_size = 0;
        int             print_min_size = 0;
        int             fd, ret;
-       blk_t           new_size = 0;
-       blk_t           max_size = 0;
-       blk_t           min_size = 0;
+       blk64_t         new_size = 0;
+       blk64_t         max_size = 0;
+       blk64_t         min_size = 0;
        io_manager      io_ptr;
        char            *new_size_str = 0;
        int             use_stride = -1;
@@ -353,7 +353,7 @@ int main (int argc, char ** argv)
                                device_name);
                        exit(1);
                }
-               printf(_("Estimated minimum size of the filesystem: %u\n"),
+               printf(_("Estimated minimum size of the filesystem: %llu\n"),
                       min_size);
                exit(0);
        }
@@ -375,8 +375,8 @@ int main (int argc, char ** argv)
         * defaults and for making sure the new filesystem doesn't
         * exceed the partition size.
         */
-       retval = ext2fs_get_device_size(device_name, fs->blocksize,
-                                       &max_size);
+       retval = ext2fs_get_device_size2(device_name, fs->blocksize,
+                                        &max_size);
        if (retval) {
                com_err(program_name, retval,
                        _("while trying to determine filesystem size"));
@@ -385,8 +385,8 @@ int main (int argc, char ** argv)
        if (force_min_size)
                new_size = min_size;
        else if (new_size_str) {
-               new_size = parse_num_blocks(new_size_str,
-                                           fs->super->s_log_block_size);
+               new_size = parse_num_blocks2(new_size_str,
+                                            fs->super->s_log_block_size);
                if (new_size == 0) {
                        com_err(program_name, 0,
                                _("Invalid new size: %s\n"), new_size_str);
@@ -401,7 +401,7 @@ int main (int argc, char ** argv)
 
        if (!force && new_size < min_size) {
                com_err(program_name, 0,
-                       _("New size smaller than minimum (%u)\n"), min_size);
+                       _("New size smaller than minimum (%llu)\n"), min_size);
                exit(1);
        }
        if (use_stride >= 0) {
@@ -432,13 +432,13 @@ int main (int argc, char ** argv)
        }
        if (!force && (new_size > max_size)) {
                fprintf(stderr, _("The containing partition (or device)"
-                       " is only %u (%dk) blocks.\nYou requested a new size"
-                       " of %u blocks.\n\n"), max_size,
+                       " is only %llu (%dk) blocks.\nYou requested a new size"
+                       " of %llu blocks.\n\n"), max_size,
                        fs->blocksize / 1024, new_size);
                exit(1);
        }
        if (new_size == ext2fs_blocks_count(fs->super)) {
-               fprintf(stderr, _("The filesystem is already %u blocks "
+               fprintf(stderr, _("The filesystem is already %llu blocks "
                        "long.  Nothing to do!\n\n"), new_size);
                exit(0);
        }
@@ -454,7 +454,7 @@ int main (int argc, char ** argv)
                        exit(1);
                }
                printf(_("Resizing the filesystem on "
-                        "%s to %u (%dk) blocks.\n"),
+                        "%s to %llu (%dk) blocks.\n"),
                       device_name, new_size, fs->blocksize / 1024);
                retval = resize_fs(fs, &new_size, flags,
                                   ((flags & RESIZE_PERCENT_COMPLETE) ?
@@ -471,7 +471,7 @@ int main (int argc, char ** argv)
                ext2fs_close(fs);
                exit(1);
        }
-       printf(_("The filesystem on %s is now %u blocks long.\n\n"),
+       printf(_("The filesystem on %s is now %llu blocks long.\n\n"),
               device_name, new_size);
 
        if ((st_buf.st_size > new_file_size) &&

diff --git a/resize/online.c b/resize/online.c
index d73b9f6a3ccb8d3e1f4a0fb42f65166382206ade..9949d604e6b9b36089d3e534421229f2de14f6f0 100644 (file)
--- a/resize/online.c
+++ b/resize/online.c
@@ -19,7 +19,7 @@
 extern char *program_name;
 
 errcode_t online_resize_fs(ext2_filsys fs, const char *mtpt,
-                          blk_t *new_size, int flags EXT2FS_ATTR((unused)))
+                          blk64_t *new_size, int flags EXT2FS_ATTR((unused)))
 {
 #ifdef __linux__
        struct ext2_new_group_input input;
@@ -30,7 +30,7 @@ errcode_t online_resize_fs(ext2_filsys fs, const char *mtpt,
        errcode_t               retval;
        double                  percent;
        dgrp_t                  i;
-       blk_t                   size;
+       blk64_t                 size;
        int                     fd, overhead;
        int                     use_old_ioctl = 1;
 
@@ -38,7 +38,7 @@ errcode_t online_resize_fs(ext2_filsys fs, const char *mtpt,
                 "on-line resizing required\n"), fs->device_name, mtpt);
 
        if (*new_size < ext2fs_blocks_count(sb)) {
-               printf(_("On-line shrinking from %llu to %u not supported.\n"),
+               printf(_("On-line shrinking from %llu to %llu not supported.\n"),
                       ext2fs_blocks_count(sb), *new_size);
                exit(1);
        }
@@ -48,9 +48,9 @@ errcode_t online_resize_fs(ext2_filsys fs, const char *mtpt,
         * the on-line resizing inode must be present.
         */
        new_desc_blocks = ext2fs_div_ceil(
-               ext2fs_div_ceil(*new_size -
-                               fs->super->s_first_data_block,
-                               EXT2_BLOCKS_PER_GROUP(fs->super)),
+               ext2fs_div64_ceil(*new_size -
+                                 fs->super->s_first_data_block,
+                                 EXT2_BLOCKS_PER_GROUP(fs->super)),
                EXT2_DESC_PER_BLOCK(fs->super));
        printf("old desc_blocks = %lu, new_desc_blocks = %lu\n",
               fs->desc_blocks, new_desc_blocks);
@@ -109,7 +109,7 @@ errcode_t online_resize_fs(ext2_filsys fs, const char *mtpt,
        if (retval)
                return retval;
 
-       printf(_("Performing an on-line resize of %s to %u (%dk) blocks.\n"),
+       printf(_("Performing an on-line resize of %s to %llu (%dk) blocks.\n"),
               fs->device_name, *new_size, fs->blocksize / 1024);
 
        size = fs->group_desc_count * sb->s_blocks_per_group +

diff --git a/resize/resize2fs.c b/resize/resize2fs.c
index 818b7b7b131bfed895053f5ebec273c65400f6cb..064c4c482ba66bec559a131650a883365a72eb81 100644 (file)
--- a/resize/resize2fs.c
+++ b/resize/resize2fs.c
@@ -41,7 +41,7 @@
 #endif
 
 static void fix_uninit_block_bitmaps(ext2_filsys fs);
-static errcode_t adjust_superblock(ext2_resize_t rfs, blk_t new_size);
+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);
@@ -68,7 +68,7 @@ static errcode_t fix_sb_journal_backup(ext2_filsys fs);
 /*
  * This is the top-level routine which does the dirty deed....
  */
-errcode_t resize_fs(ext2_filsys fs, blk_t *new_size, int flags,
+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))
@@ -119,7 +119,7 @@ errcode_t resize_fs(ext2_filsys fs, blk_t *new_size, int flags,
 
 #ifdef RESIZE2FS_DEBUG
        if (rfs->flags & RESIZE_DEBUG_BMOVE)
-               printf("Number of free blocks: %llu/%llu, Needed: %d\n",
+               printf("Number of free blocks: %llu/%llu, Needed: %llu\n",
                       ext2fs_free_blocks_count(rfs->old_fs->super),
                       ext2fs_free_blocks_count(rfs->new_fs->super),
                       rfs->needed_blocks);
@@ -186,7 +186,7 @@ errout:
  */
 static void fix_uninit_block_bitmaps(ext2_filsys fs)
 {
-       blk_t           i, blk, super_blk, old_desc_blk, new_desc_blk;
+       blk64_t         i, blk, super_blk, old_desc_blk, new_desc_blk;
        int             old_desc_blocks;
        dgrp_t          g;
 
@@ -201,8 +201,8 @@ static void fix_uninit_block_bitmaps(ext2_filsys fs)
                blk = (g * fs->super->s_blocks_per_group) +
                        fs->super->s_first_data_block;
 
-               ext2fs_super_and_bgd_loc(fs, g, &super_blk,
-                                        &old_desc_blk, &new_desc_blk, 0);
+               ext2fs_super_and_bgd_loc2(fs, g, &super_blk,
+                                         &old_desc_blk, &new_desc_blk, 0);
 
                if (fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_META_BG)
                        old_desc_blocks = fs->super->s_first_meta_bg;
@@ -288,14 +288,14 @@ static void free_gdp_blocks(ext2_filsys fs,
  * filesystem.
  */
 errcode_t adjust_fs_info(ext2_filsys fs, ext2_filsys old_fs,
-                        ext2fs_block_bitmap reserve_blocks, blk_t new_size)
+                        ext2fs_block_bitmap reserve_blocks, blk64_t new_size)
 {
        errcode_t       retval;
-       int             overhead = 0;
-       int             rem;
-       blk_t           blk, group_block;
+       blk64_t         overhead = 0;
+       blk64_t         rem;
+       blk64_t         blk, group_block;
        ext2_ino_t      real_end;
-       int             adj, old_numblocks, numblocks, adjblocks;
+       blk64_t         adj, old_numblocks, numblocks, adjblocks;
        unsigned long   i, j, old_desc_blocks, max_group;
        unsigned int    meta_bg, meta_bg_size;
        int             has_super, csum_flag;
@@ -566,12 +566,12 @@ errout:
  * 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, blk_t new_size)
+static errcode_t adjust_superblock(ext2_resize_t rfs, blk64_t new_size)
 {
        ext2_filsys fs;
        int             adj = 0;
        errcode_t       retval;
-       blk_t           group_block;
+       blk64_t         group_block;
        unsigned long   i;
        unsigned long   max_group;
 
@@ -684,7 +684,7 @@ errout:
 static errcode_t mark_table_blocks(ext2_filsys fs,
                                   ext2fs_block_bitmap bmap)
 {
-       blk_t                   b;
+       blk64_t                 b;
        unsigned int            j;
        dgrp_t                  i;
        unsigned long           meta_bg_size;
@@ -729,7 +729,7 @@ static errcode_t mark_table_blocks(ext2_filsys fs,
  */
 static void mark_fs_metablock(ext2_resize_t rfs,
                              ext2fs_block_bitmap meta_bmap,
-                             int group, blk_t blk)
+                             int group, blk64_t blk)
 {
        ext2_filsys     fs = rfs->new_fs;
 
@@ -775,8 +775,8 @@ static errcode_t blocks_to_move(ext2_resize_t rfs)
 {
        int             j, has_super;
        dgrp_t          i, max_groups, g;
-       blk_t           blk, group_blk;
-       unsigned long   old_blocks, new_blocks;
+       blk64_t         blk, group_blk;
+       blk64_t         old_blocks, new_blocks;
        unsigned int    meta_bg, meta_bg_size;
        errcode_t       retval;
        ext2_filsys     fs, old_fs;
@@ -1043,7 +1043,7 @@ static void init_block_alloc(ext2_resize_t rfs)
 #endif
 }
 
-static blk_t get_new_block(ext2_resize_t rfs)
+static blk64_t get_new_block(ext2_resize_t rfs)
 {
        ext2_filsys     fs = rfs->new_fs;
 
@@ -1079,7 +1079,7 @@ static errcode_t resize2fs_get_alloc_block(ext2_filsys fs, blk64_t goal,
                                           blk64_t *ret)
 {
        ext2_resize_t rfs = (ext2_resize_t) fs->priv_data;
-       blk_t blk;
+       blk64_t blk;
 
        blk = get_new_block(rfs);
        if (!blk)
@@ -1087,7 +1087,7 @@ static errcode_t resize2fs_get_alloc_block(ext2_filsys fs, blk64_t goal,
 
 #ifdef RESIZE2FS_DEBUG
        if (rfs->flags & 0xF)
-               printf("get_alloc_block allocating %u\n", blk);
+               printf("get_alloc_block allocating %llu\n", blk);
 #endif
 
        ext2fs_mark_block_bitmap2(rfs->old_fs->block_map, blk);
@@ -1098,11 +1098,12 @@ static errcode_t resize2fs_get_alloc_block(ext2_filsys fs, blk64_t goal,
 
 static errcode_t block_mover(ext2_resize_t rfs)
 {
-       blk_t                   blk, old_blk, new_blk;
+       blk64_t                 blk, old_blk, new_blk;
        ext2_filsys             fs = rfs->new_fs;
        ext2_filsys             old_fs = rfs->old_fs;
        errcode_t               retval;
-       int                     size, c;
+       __u64                   size;
+       int                     c;
        int                     to_move, moved;
        ext2_badblocks_list     badblock_list = 0;
        int                     bb_modified = 0;
@@ -1182,7 +1183,7 @@ static errcode_t block_mover(ext2_resize_t rfs)
                        break;
 #ifdef RESIZE2FS_DEBUG
                if (rfs->flags & RESIZE_DEBUG_BMOVE)
-                       printf("Moving %d blocks %u->%u\n",
+                       printf("Moving %llu blocks %llu->%llu\n",
                               size, old_blk, new_blk);
 #endif
                do {
@@ -1239,14 +1240,14 @@ struct process_block_struct {
        int                     changed;
 };
 
-static int process_block(ext2_filsys fs, blk_t *block_nr,
+static int process_block(ext2_filsys fs, blk64_t       *block_nr,
                         e2_blkcnt_t blockcnt,
-                        blk_t ref_block EXT2FS_ATTR((unused)),
+                        blk64_t ref_block EXT2FS_ATTR((unused)),
                         int ref_offset EXT2FS_ATTR((unused)), void *priv_data)
 {
        struct process_block_struct *pb;
        errcode_t       retval;
-       blk_t           block, new_block;
+       blk64_t         block, new_block;
        int             ret = 0;
 
        pb = (struct process_block_struct *) priv_data;
@@ -1259,15 +1260,15 @@ static int process_block(ext2_filsys fs, blk_t  *block_nr,
                        pb->changed = 1;
 #ifdef RESIZE2FS_DEBUG
                        if (pb->rfs->flags & RESIZE_DEBUG_BMOVE)
-                               printf("ino=%u, blockcnt=%lld, %u->%u\n",
+                               printf("ino=%u, blockcnt=%lld, %llu->%llu\n",
                                       pb->ino, blockcnt, block, new_block);
 #endif
                        block = new_block;
                }
        }
        if (pb->is_dir) {
-               retval = ext2fs_add_dir_block(fs->dblist, pb->ino,
-                                             block, (int) blockcnt);
+               retval = ext2fs_add_dir_block2(fs->dblist, pb->ino,
+                                              block, (int) blockcnt);
                if (retval) {
                        pb->error = retval;
                        ret |= BLOCK_ABORT;
@@ -1313,7 +1314,8 @@ static errcode_t inode_scan_and_fix(ext2_resize_t rfs)
        errcode_t               retval;
        char                    *block_buf = 0;
        ext2_ino_t              start_to_move;
-       blk_t                   orig_size, new_block;
+       blk64_t                 orig_size;
+       blk64_t                 new_block;
        int                     inode_size;
 
        if ((rfs->old_fs->group_desc_count <=
@@ -1390,7 +1392,7 @@ static errcode_t inode_scan_and_fix(ext2_resize_t rfs)
                if (ext2fs_inode_has_valid_blocks(inode) &&
                    (rfs->bmap || pb.is_dir)) {
                        pb.ino = ino;
-                       retval = ext2fs_block_iterate2(rfs->old_fs,
+                       retval = ext2fs_block_iterate3(rfs->old_fs,
                                                       ino, 0, block_buf,
                                                       process_block, &pb);
                        if (retval)
@@ -1527,7 +1529,7 @@ static errcode_t inode_ref_fix(ext2_resize_t rfs)
         * inode references
         */
        is.num = 0;
-       is.max_dirs = ext2fs_dblist_count(rfs->old_fs->dblist);
+       is.max_dirs = ext2fs_dblist_count2(rfs->old_fs->dblist);
        is.rfs = rfs;
        is.err = 0;
 
@@ -1581,11 +1583,12 @@ errout:
  */
 static errcode_t move_itables(ext2_resize_t rfs)
 {
-       int             n, num, size, diff;
+       int             n, num, size;
+       long long       diff;
        dgrp_t          i, max_groups;
        ext2_filsys     fs = rfs->new_fs;
        char            *cp;
-       blk_t           old_blk, new_blk, blk;
+       blk64_t         old_blk, new_blk, blk;
        errcode_t       retval;
        int             j, to_move, moved;
 
@@ -1628,7 +1631,7 @@ static errcode_t move_itables(ext2_resize_t rfs)
 
 #ifdef RESIZE2FS_DEBUG
                if (rfs->flags & RESIZE_DEBUG_ITABLEMOVE)
-                       printf("Itable move group %d block %u->%u (diff %d)\n",
+                       printf("Itable move group %d block %llu->%llu (diff %lld)\n",
                               i, old_blk, new_blk, diff);
 #endif
 
@@ -1712,7 +1715,7 @@ static errcode_t fix_resize_inode(ext2_filsys fs)
        struct ext2_inode       inode;
        errcode_t               retval;
        char *                  block_buf;
-       blk_t                   blk;
+       blk64_t                 blk;
 
        if (!(fs->super->s_feature_compat &
              EXT2_FEATURE_COMPAT_RESIZE_INODE))
@@ -1775,22 +1778,22 @@ errout:
  */
 static errcode_t ext2fs_calculate_summary_stats(ext2_filsys fs)
 {
-       blk_t           blk;
+       blk64_t         blk;
        ext2_ino_t      ino;
        unsigned int    group = 0;
        unsigned int    count = 0;
        int             total_free = 0;
        int             group_free = 0;
        int             uninit = 0;
-       blk_t           super_blk, old_desc_blk, new_desc_blk;
+       blk64_t         super_blk, old_desc_blk, new_desc_blk;
        int             old_desc_blocks;
 
        /*
         * First calculate the block statistics
         */
        uninit = ext2fs_bg_flags_test(fs, group, EXT2_BG_BLOCK_UNINIT);
-       ext2fs_super_and_bgd_loc(fs, group, &super_blk, &old_desc_blk,
-                                &new_desc_blk, 0);
+       ext2fs_super_and_bgd_loc2(fs, group, &super_blk, &old_desc_blk,
+                                 &new_desc_blk, 0);
        if (fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_META_BG)
                old_desc_blocks = fs->super->s_first_meta_bg;
        else
@@ -1823,11 +1826,10 @@ static errcode_t ext2fs_calculate_summary_stats(ext2_filsys fs)
                                break;
                        count = 0;
                        group_free = 0;
-                       uninit = (ext2fs_bg_flags_test(fs, group, EXT2_BG_BLOCK_UNINIT)
-                                 );
-                       ext2fs_super_and_bgd_loc(fs, group, &super_blk,
-                                                &old_desc_blk,
-                                                &new_desc_blk, 0);
+                       uninit = ext2fs_bg_flags_test(fs, group, EXT2_BG_BLOCK_UNINIT);
+                       ext2fs_super_and_bgd_loc2(fs, group, &super_blk,
+                                                 &old_desc_blk,
+                                                 &new_desc_blk, 0);
                        if (fs->super->s_feature_incompat &
                            EXT2_FEATURE_INCOMPAT_META_BG)
                                old_desc_blocks = fs->super->s_first_meta_bg;
@@ -1901,11 +1903,13 @@ static errcode_t fix_sb_journal_backup(ext2_filsys fs)
 /*
  * calcluate the minimum number of blocks the given fs can be resized to
  */
-blk_t calculate_minimum_resize_size(ext2_filsys fs)
+blk64_t calculate_minimum_resize_size(ext2_filsys fs)
 {
-       blk_t inode_count, blks_needed, groups, data_blocks;
-       blk_t grp, data_needed, last_start;
-       int overhead = 0, num_of_superblocks = 0;
+       ext2_ino_t inode_count;
+       blk64_t blks_needed, groups, data_blocks;
+       blk64_t grp, data_needed, last_start;
+       blk64_t overhead = 0;
+       int num_of_superblocks = 0;
        int extra_groups = 0;
        int flexbg_size = 1 << fs->super->s_log_groups_per_flex;
 
@@ -1918,8 +1922,8 @@ blk_t calculate_minimum_resize_size(ext2_filsys fs)
        blks_needed = ext2fs_div_ceil(inode_count,
                                      fs->super->s_inodes_per_group) *
                EXT2_BLOCKS_PER_GROUP(fs->super);
-       groups = ext2fs_div_ceil(blks_needed,
-                                EXT2_BLOCKS_PER_GROUP(fs->super));
+       groups = ext2fs_div64_ceil(blks_needed,
+                                  EXT2_BLOCKS_PER_GROUP(fs->super));
 
        /*
         * we need to figure out how many backup superblocks we have so we can
@@ -1976,12 +1980,12 @@ blk_t calculate_minimum_resize_size(ext2_filsys fs)
         * then we need to add them here
         */
        while (data_needed > data_blocks) {
-               blk_t remainder = data_needed - data_blocks;
-               blk_t extra_grps;
+               blk64_t remainder = data_needed - data_blocks;
+               blk64_t extra_grps;
 
                /* figure out how many more groups we need for the data */
-               extra_grps = ext2fs_div_ceil(remainder,
-                                            EXT2_BLOCKS_PER_GROUP(fs->super));
+               extra_grps = ext2fs_div64_ceil(remainder,
+                                              EXT2_BLOCKS_PER_GROUP(fs->super));
 
                data_blocks += extra_grps * EXT2_BLOCKS_PER_GROUP(fs->super);
 
@@ -2032,7 +2036,7 @@ blk_t calculate_minimum_resize_size(ext2_filsys fs)
         * so we need to adjust the size of the last group accordingly
         */
        if (last_start < data_needed) {
-               blk_t remainder = data_needed - last_start;
+               blk64_t remainder = data_needed - last_start;
 
                /*
                 * 50 is a magic number that mkfs/resize uses to see if its

diff --git a/resize/resize2fs.h b/resize/resize2fs.h
index fab7290f412371c0d556724e8e59054370cc379c..21847593673170f6a1cfe813435d9920559e8bbf 100644 (file)
--- a/resize/resize2fs.h
+++ b/resize/resize2fs.h
@@ -92,14 +92,14 @@ struct ext2_resize_struct {
        ext2fs_block_bitmap move_blocks;
        ext2_extent     bmap;
        ext2_extent     imap;
-       int             needed_blocks;
+       blk64_t         needed_blocks;
        int             flags;
        char            *itable_buf;
 
        /*
         * For the block allocator
         */
-       blk_t           new_blk;
+       blk64_t         new_blk;
        int             alloc_state;
 
        /*
@@ -122,31 +122,31 @@ struct ext2_resize_struct {
 
 
 /* prototypes */
-extern errcode_t resize_fs(ext2_filsys fs, blk_t *new_size, int flags,
+extern 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));
 
 extern errcode_t adjust_fs_info(ext2_filsys fs, ext2_filsys old_fs,
                                ext2fs_block_bitmap reserve_blocks,
-                               blk_t new_size);
-extern blk_t calculate_minimum_resize_size(ext2_filsys fs);
+                               blk64_t new_size);
+extern blk64_t calculate_minimum_resize_size(ext2_filsys fs);
 
 
 /* extent.c */
 extern errcode_t ext2fs_create_extent_table(ext2_extent *ret_extent,
-                                           int size);
+                                           __u64 size);
 extern void ext2fs_free_extent_table(ext2_extent extent);
 extern errcode_t ext2fs_add_extent_entry(ext2_extent extent,
-                                        __u32 old_loc, __u32 new_loc);
-extern __u32 ext2fs_extent_translate(ext2_extent extent, __u32 old_loc);
+                                        __u64 old_loc, __u64 new_loc);
+extern __u64 ext2fs_extent_translate(ext2_extent extent, __u64 old_loc);
 extern void ext2fs_extent_dump(ext2_extent extent, FILE *out);
-extern errcode_t ext2fs_iterate_extent(ext2_extent extent, __u32 *old_loc,
-                                      __u32 *new_loc, int *size);
+extern errcode_t ext2fs_iterate_extent(ext2_extent extent, __u64 *old_loc,
+                                      __u64 *new_loc, __u64 *size);
 
 /* online.c */
 extern errcode_t online_resize_fs(ext2_filsys fs, const char *mtpt,
-                                 blk_t *new_size, int flags);
+                                 blk64_t *new_size, int flags);
 
 /* sim_progress.c */
 extern errcode_t ext2fs_progress_init(ext2_sim_progmeter *ret_prog,

diff --git a/resize/test_extent.c b/resize/test_extent.c
index 887b47606b0e5caf20642f9c3d2800465301053c..a8678f1f04c6a956c19caca2febc38847c6c16b1 100644 (file)
--- a/resize/test_extent.c
+++ b/resize/test_extent.c
@@ -20,8 +20,8 @@ void do_test(FILE *in, FILE *out)
 {
        char            buf[128];
        char            *cp, *cmd, *arg1, *arg2;
-       __u32           num1, num2;
-       int             size;
+       __u64           num1, num2;
+       __u64           size;
        errcode_t       retval;
        ext2_extent     extent = 0;
        const char      *no_table = "# No extent table\n";
@@ -87,7 +87,7 @@ void do_test(FILE *in, FILE *out)
                                goto handle_error;
                } else if (!strcmp(cmd, "lookup")) {
                        num2 = ext2fs_extent_translate(extent, num1);
-                       fprintf(out, "# Answer: %u%s\n", num2,
+                       fprintf(out, "# Answer: %llu%s\n", num2,
                                num2 ? "" : " (not found)");
                } else if (!strcmp(cmd, "dump")) {
                        ext2fs_extent_dump(extent, out);
@@ -102,7 +102,7 @@ void do_test(FILE *in, FILE *out)
                                        goto handle_error;
                                if (!size)
                                        break;
-                               fprintf(out, "# %u -> %u (%d)\n",
+                               fprintf(out, "# %llu -> %llu (%llu)\n",
                                        num1, num2, size);
                        }
                } else