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>

6 files changed, 115 insertions, 111 deletions

diff --git a/resize/extent.c b/resize/extent.c
index 2ed7591d..0da8df6d 100644
--- 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 fd85d903..bb3c404b 100644
--- 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;
@@ -345,7 +345,7 @@ int main (int argc, char ** argv)
 	min_size = calculate_minimum_resize_size(fs);
 
 	if (print_min_size) {
-		printf(_("Estimated minimum size of the filesystem: %u\n"),
+		printf(_("Estimated minimum size of the filesystem: %llu\n"),
 		       min_size);
 		exit(0);
 	}
@@ -367,8 +367,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"));
@@ -377,8 +377,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);
@@ -393,7 +393,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) {
@@ -424,13 +424,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);
 	}
@@ -446,7 +446,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) ?
@@ -463,7 +463,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 d73b9f6a..9949d604 100644
--- 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 818b7b7b..064c4c48 100644
--- 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 fab7290f..21847593 100644
--- 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 887b4760..a8678f1f 100644
--- 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