--- old/usr/src/lib/libparted/common/libparted/fs/ext2/ext2_resize.c	2014-07-17 16:13:49.135740971 +0200
+++ /dev/null	2014-07-17 16:13:49.000000000 +0200
@@ -1,730 +0,0 @@
-/*
-    ext2_resize.c -- ext2 resizer
-    Copyright (C) 1998-2000, 2007 Free Software Foundation, Inc.
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include <config.h>
-
-#ifndef DISCOVER_ONLY
-
-#include <stdio.h>
-#include <stdlib.h>
-#include "ext2.h"
-
-static int ext2_add_group(struct ext2_fs *fs, blk_t groupsize)
-{
-	blk_t admin;
-	int   group;
-	blk_t groupstart;
-	blk_t newgdblocks;
-	int   sparse;
-
-	if (fs->opt_verbose)
-                fputs ("ext2_add_group\n", stderr);
-
-	if (!ped_realloc ((void*) &fs->gd,
-			  (fs->numgroups+1) * sizeof(struct ext2_group_desc)
-			      + fs->blocksize))
-		return 0;
-
-	if (fs->opt_debug)
-	{
-		if (EXT2_SUPER_BLOCKS_COUNT(fs->sb) !=
-		    EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb)
-		    + fs->numgroups * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb))
-		{
-                        fputs ("ext2_add_group: last (existing) group "
-                               "isn't complete!\n", stderr);
-
-			return 0;
-		}
-	}
-
-	group = fs->numgroups;
-	sparse = ext2_is_group_sparse(fs, group);
-	groupstart = EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb)
-		     + group * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
-
-	admin = fs->adminblocks;
-	if (!sparse)
-		admin -= fs->gdblocks + 1;
-
-	if (fs->opt_debug)
-	{
-		if (groupsize < fs->adminblocks ||
-		    groupsize > EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb))
-		{
-			fprintf(stderr,
-				"ext2_add_group: groups of %i blocks are "
-				"impossible!\n", groupsize);
-
-			return 0;
-		}
-	}
-
-	newgdblocks = ped_div_round_up((fs->numgroups + 1)
-					* sizeof(struct ext2_group_desc),
-			      fs->blocksize);
-	if (newgdblocks != fs->gdblocks)
-	{
-		int i;
-
-		for (i=0;i<fs->numgroups;i++)
-			if (ext2_is_group_sparse(fs, i))
-			{
-				blk_t start;
-
-				start = EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb)
-				      + i * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
-				ext2_set_block_state(fs,
-						start + fs->gdblocks + 1, 1, 1);
-			}
-
-		fs->gdblocks++;
-		fs->adminblocks++;
-		if (sparse)
-			admin++;
-	}
-
-	fs->numgroups++;
-
-	fs->sb.s_inodes_count = PED_CPU_TO_LE32(
-		EXT2_SUPER_INODES_COUNT(fs->sb)
-		+ EXT2_SUPER_INODES_PER_GROUP(fs->sb));
-	fs->sb.s_blocks_count = PED_CPU_TO_LE32(
-		EXT2_SUPER_BLOCKS_COUNT(fs->sb) + groupsize);
-	fs->sb.s_free_blocks_count = PED_CPU_TO_LE32(
-		EXT2_SUPER_FREE_BLOCKS_COUNT(fs->sb) + groupsize - admin);
-	fs->sb.s_free_inodes_count = PED_CPU_TO_LE32(
-		EXT2_SUPER_FREE_INODES_COUNT(fs->sb)
-	        + EXT2_SUPER_INODES_PER_GROUP(fs->sb));
-	fs->metadirty |= EXT2_META_SB;
-
-	{
-		blk_t off;
-		blk_t sparseoff;
-
-		off = groupstart;
-		sparseoff = off + fs->itoffset - 2;
-
-		if (sparse)
-		{
-			fs->gd[group].bg_block_bitmap
-				= PED_CPU_TO_LE32(sparseoff);
-			fs->gd[group].bg_inode_bitmap
-				= PED_CPU_TO_LE32(sparseoff + 1);
-		}
-		else
-		{
-			fs->gd[group].bg_block_bitmap
-				= PED_CPU_TO_LE32(off);
-			fs->gd[group].bg_inode_bitmap
-				= PED_CPU_TO_LE32(off + 1);
-		}
-
-		/* Hey, I don't know _why_ either */
-		fs->gd[group].bg_inode_table = PED_CPU_TO_LE32(sparseoff + 2);
-	}
-
-	fs->gd[group].bg_free_blocks_count = PED_CPU_TO_LE16(groupsize - admin);
-	fs->gd[group].bg_free_inodes_count = PED_CPU_TO_LE16(
-		EXT2_SUPER_INODES_PER_GROUP(fs->sb));
-	fs->gd[group].bg_used_dirs_count = 0;
-	fs->metadirty |= EXT2_META_SB | EXT2_META_GD;
-
-	{
-		struct ext2_buffer_head *bh;
-		blk_t i;
-
-		bh = ext2_bcreate(fs, EXT2_GROUP_BLOCK_BITMAP(fs->gd[group]));
-		if (!bh)
-			return 0;
-
-		if (sparse)
-		{
-			bh->data[0] |= _bitmap[0];
-			for (i=1;i<=fs->gdblocks;i++)
-				bh->data[i>>3] |= _bitmap[i&7];
-		}
-
-		i = EXT2_GROUP_BLOCK_BITMAP(fs->gd[group]) - groupstart;
-		bh->data[i>>3] |= _bitmap[i&7];
-
-		i = EXT2_GROUP_INODE_BITMAP(fs->gd[group]) - groupstart;
-		bh->data[i>>3] |= _bitmap[i&7];
-
-		for (i=0;i<fs->inodeblocks;i++)
-		{
-			blk_t j;
-
-			j = EXT2_GROUP_INODE_TABLE(fs->gd[group])
-			    - groupstart + i;
-			bh->data[j>>3] |= _bitmap[j&7];
-		}
-
-		for (i=groupsize;i<EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);i++)
-			bh->data[i>>3] |= _bitmap[i&7];
-
-		ext2_brelse(bh, 0);         /* this is a block bitmap */
-	}
-
-	if (!ext2_zero_blocks(fs, EXT2_GROUP_INODE_BITMAP(fs->gd[group]), 1))
-		return 0;
-	if (!ext2_zero_blocks(fs, EXT2_GROUP_INODE_TABLE(fs->gd[group]),
-			      fs->inodeblocks))
-		return 0;
-
-	if (fs->opt_safe)
-		if (!ext2_sync(fs))
-			return 0;
-
-	return 1;
-}
-
-static int ext2_del_group(struct ext2_fs *fs)
-{
-	blk_t admin;
-	int   group;
-	blk_t groupsize;
-	blk_t newgdblocks;
-	int   sparse;
-
-	if (fs->opt_verbose)
-                fputs ("ext2_del_group\n", stderr);
-
-	group = fs->numgroups - 1;
-	sparse = ext2_is_group_sparse(fs, group);
-
-	admin = fs->adminblocks;
-	if (!sparse)
-		admin -= fs->gdblocks + 1;
-
-	groupsize = EXT2_SUPER_BLOCKS_COUNT(fs->sb)
-		  - EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb)
-		  - group * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
-
-	if (EXT2_SUPER_FREE_BLOCKS_COUNT(fs->sb) < groupsize - admin)
-	{
-		ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
-			_("File system is too full to remove a group!"));
-
-		return 0;
-	}
-
-	if (EXT2_SUPER_FREE_INODES_COUNT(fs->sb)
-		< EXT2_SUPER_INODES_PER_GROUP(fs->sb))
-	{
-		ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
-			_("File system has too many allocated inodes to "
-			  "remove a group!"));
-		return 0;
-	}
-
-	if (fs->opt_debug)
-	{
-		if (EXT2_GROUP_FREE_INODES_COUNT(fs->gd[group]) !=
-		    EXT2_SUPER_INODES_PER_GROUP(fs->sb))
-		{
-                        fputs ("ext2_del_group: this should not "
-                               "happen anymore!\n", stderr);
-
-			return 0;
-		}
-	}
-
-	newgdblocks = ped_div_round_up((fs->numgroups - 1) *
-			      sizeof(struct ext2_group_desc), fs->blocksize);
-
-	if (newgdblocks != fs->gdblocks)
-	{
-		int i;
-
-		for (i=0;i<fs->numgroups;i++)
-			if (ext2_is_group_sparse(fs, i))
-			{
-				blk_t start;
-
-				start = EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb) +
-					i * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
-				ext2_set_block_state(fs,
-						     start + fs->gdblocks,
-						     0, 1);
-			}
-
-		fs->gdblocks--;
-		fs->adminblocks--;
-		if (sparse)
-			admin--;
-	}
-
-	if (fs->opt_debug)
-	{
-		if (EXT2_GROUP_FREE_BLOCKS_COUNT(fs->gd[group])
-				!= groupsize - admin)
-		{
-			blk_t i;
-			blk_t num;
-			blk_t offset;
-
-			offset = EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb) +
-				group * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
-			num = EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
-
-			for (i=0;i<num;i++)
-				if (ext2_is_data_block(fs, offset+i) &&
-				    ext2_get_block_state(fs, offset+i))
-				{
-					fprintf(stderr,
-						"error: block relocator "
-						"should have relocated "
-						"%i\n",
-						offset+i);
-
-					return 0;
-				}
-		}
-	}
-
-	fs->numgroups--;
-
-	fs->sb.s_inodes_count = PED_CPU_TO_LE32(
-		EXT2_SUPER_INODES_COUNT(fs->sb)
-		- EXT2_SUPER_INODES_PER_GROUP(fs->sb));
-	fs->sb.s_blocks_count = PED_CPU_TO_LE32(
-		EXT2_SUPER_BLOCKS_COUNT(fs->sb) - groupsize);
-	fs->sb.s_free_blocks_count = PED_CPU_TO_LE32(
-		EXT2_SUPER_FREE_BLOCKS_COUNT(fs->sb) - (groupsize - admin));
-	fs->sb.s_free_inodes_count = PED_CPU_TO_LE32(
-		EXT2_SUPER_FREE_INODES_COUNT(fs->sb)
-	        - EXT2_SUPER_INODES_PER_GROUP(fs->sb));
-	fs->metadirty |= EXT2_META_SB;
-
-	if (fs->opt_safe)
-		ext2_sync(fs);
-
-	ped_realloc ((void*) &fs->gd,
-		     fs->numgroups * sizeof(struct ext2_group_desc)
-			      + fs->blocksize);
-
-	return 1;
-}
-
-static int ext2_grow_group(struct ext2_fs *fs, blk_t newsize)
-{
-	int   group;
-	blk_t groupoff;
-	blk_t gblocks;
-	blk_t i;
-
-	if (fs->opt_verbose)
-                fputs ("ext2_grow_group\n", stderr);
-
-	group = fs->numgroups - 1;
-	groupoff = group * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb)
-		   + EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb);
-	gblocks = EXT2_SUPER_BLOCKS_COUNT(fs->sb) - groupoff;
-
-	if (fs->opt_debug)
-	{
-		if (newsize < gblocks)
-		{
-                        fputs ("ext2_grow_group: called to shrink group!\n",
-                               stderr);
-
-			return 0;
-		}
-
-		if (gblocks == newsize)
-		{
-                        fputs ("ext2_grow_group: nothing to do!\n", stderr);
-			return 0;
-		}
-	}
-
-	for (i=gblocks;i<newsize;i++)
-		ext2_set_block_state(fs, groupoff + i, 0, 1);
-
-	fs->sb.s_blocks_count = PED_CPU_TO_LE32(
-		EXT2_SUPER_BLOCKS_COUNT(fs->sb) + newsize - gblocks);
-	fs->metadirty |= EXT2_META_SB;
-
-	if (fs->opt_safe)
-		ext2_sync(fs);
-
-	return 1;
-}
-
-static int ext2_shrink_group(struct ext2_fs *fs, blk_t newsize)
-{
-	blk_t admin;
-	int   group;
-	blk_t groupoff;
-	blk_t gblocks;
-	blk_t i;
-
-	if (fs->opt_verbose)
-                fputs ("ext2_shrink_group\n", stderr);
-
-	group = fs->numgroups - 1;
-
-	admin = fs->adminblocks;
-	if (!ext2_is_group_sparse(fs, group))
-		admin -= fs->gdblocks + 1;
-
-	groupoff = group * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb)
-		   + EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb);
-	gblocks = EXT2_SUPER_BLOCKS_COUNT(fs->sb) - groupoff;
-
-	if (fs->opt_debug)
-	{
-		if (newsize < admin)
-		{
-			fprintf(stderr,
-				"ext2_shrink_group: cant shrink a group "
-				"to %i blocks\n", newsize);
-
-			return 0;
-		}
-
-		if (newsize > gblocks)
-		{
-                        fputs ("ext2_shrink_group: called to grow group!\n",
-                               stderr);
-
-			return 0;
-		}
-
-		if (gblocks == newsize)
-		{
-                        fputs ("ext2_shrink_group: nothing to do!\n",
-                               stderr);
-
-			return 0;
-		}
-	}
-
-	for (i=newsize;i<gblocks;i++)
-	{
-		if (fs->opt_debug && ext2_get_block_state(fs, groupoff + i))
-		{
-			fprintf(stderr,
-				"error: block relocator should have relocated "
-				"%i\n",
-				groupoff + i);
-
-			return 0;
-		}
-
-		ext2_set_block_state(fs, groupoff + i, 1, 0);
-	}
-
-	i = gblocks - newsize;
-	fs->sb.s_blocks_count = PED_CPU_TO_LE32(
-		EXT2_SUPER_BLOCKS_COUNT(fs->sb) - i);
-	fs->sb.s_free_blocks_count = PED_CPU_TO_LE32(
-		EXT2_SUPER_FREE_BLOCKS_COUNT(fs->sb) - i);
-	fs->gd[group].bg_free_blocks_count = PED_CPU_TO_LE16(
-		EXT2_GROUP_FREE_BLOCKS_COUNT(fs->gd[group]) - i);
-
-	fs->metadirty |= EXT2_META_SB | EXT2_META_GD;
-
-	if (fs->opt_safe)
-		ext2_sync(fs);
-
-	return 1;
-}
-
-
-
-
-
-
-static int ext2_grow_fs(struct ext2_fs *fs, blk_t newsize, PedTimer* timer)
-{
-	blk_t diff;
-	blk_t sizelast;
-	blk_t origsize = EXT2_SUPER_BLOCKS_COUNT(fs->sb);
-
-	if (fs->opt_verbose)
-                fputs ("ext2_grow_fs\n", stderr);
-
-	if (!ext2_block_relocate(fs, newsize))
-		return 0;
-
-	if (!ext2_metadata_push(fs, newsize))
-		return 0;
-
-	diff = newsize - EXT2_SUPER_BLOCKS_COUNT(fs->sb);
-	sizelast = EXT2_SUPER_BLOCKS_COUNT(fs->sb)
-		   - EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb)
-		   - (fs->numgroups-1) * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
-
-	if (sizelast != EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb))
-	{
-		blk_t growto;
-
-		growto = sizelast + diff;
-		if (growto > EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb))
-			growto = EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
-
-		if (!ext2_grow_group(fs, growto))
-			return 0;
-
-		diff -= growto - sizelast;
-	}
-
-	ped_timer_reset (timer);
-	ped_timer_set_state_name (timer, _("adding groups"));
-
-	while (diff)
-	{
-		ped_timer_update (timer,
-			          1.0 - 1.0 * diff / (newsize - origsize));
-
-		sizelast = PED_MIN(diff, EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb));
-		if (!ext2_add_group(fs, sizelast))
-			return 0;
-
-		diff -= sizelast;
-	}
-
-	ped_timer_update (timer, 1.0);
-
-	return 1;
-}
-
-static int ext2_shrink_fs(struct ext2_fs *fs, blk_t newsize,
-			  PedTimer* timer)
-{
-	blk_t origsize = EXT2_SUPER_BLOCKS_COUNT (fs->sb);
-	blk_t diff;
-	int newgroups;
-	blk_t sizelast;
-
-	if (fs->opt_verbose)
-                fputs ("ext2_shrink_fs\n", stderr);
-
-	newgroups = ped_div_round_up (newsize
-                                - EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb),
-		        EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb));
-	if (EXT2_SUPER_BLOCKS_COUNT(fs->sb)
-	    - EXT2_SUPER_FREE_BLOCKS_COUNT(fs->sb) > newsize)
-	{
-		ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
-			_("Your file system is too full to resize it to %i "
-			  "blocks.  Sorry."), newsize);
-		return 0;
-	}
-
-	if (EXT2_SUPER_INODES_COUNT(fs->sb)
-	    - EXT2_SUPER_FREE_INODES_COUNT(fs->sb)
-	    		> newgroups * EXT2_SUPER_INODES_PER_GROUP(fs->sb))
-	{
-		ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
-			_("Your file system has too many occupied inodes to "
-			  "resize it to %i blocks.  Sorry."), newsize);
-		return 0;
-	}
-
-	if (!ext2_inode_relocate(fs, newgroups))
-		return 0;
-
-	if (!ext2_block_relocate(fs, newsize))
-		return 0;
-
-	diff = EXT2_SUPER_BLOCKS_COUNT(fs->sb) - newsize;
-
-	ped_timer_reset (timer);
-	ped_timer_set_state_name (timer, _("shrinking"));
-
-	while (diff > 0)
-	{
-		ped_timer_update (timer,
-				  1.0 - 1.0 * diff / (origsize - newsize));
-
-		sizelast = EXT2_SUPER_BLOCKS_COUNT(fs->sb)
-			   - EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb) -
-			   (fs->numgroups - 1)
-			   	* EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
-
-		if (diff < sizelast)
-		{
-			if (!ext2_shrink_group(fs, sizelast - diff))
-				return 0;
-
-			diff = 0;
-		}
-		else
-		{
-			if (!ext2_del_group(fs))
-				return 0;
-
-			diff -= sizelast;
-		}
-	}
-	
-	ped_timer_update (timer, 1.0);
-
-	return 1;
-}
-
-int ext2_determine_itoffset(struct ext2_fs *fs)
-{
-	int i;
-
-	fs->itoffset = EXT2_GROUP_INODE_TABLE(fs->gd[0])
-		       - EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb);
-
-        /*PED_DEBUG (0x20, "itoffset is %d", fs->itoffset);
-        
-        PED_DEBUG (0x20, "walking %d groups", fs->numgroups);*/
-
-	for (i=0;i<fs->numgroups;i++)
-	{
-		blk_t start;
-		blk_t bb;
-		blk_t ib;
-		blk_t it;
-
-		start = EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb)
-			+ (i * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb));
-		it = start + fs->itoffset;
-
-                /*PED_DEBUG (0x21, "start = %d, it = %d", start, it);*/
-
-		if (ext2_is_group_sparse(fs, i))
-		{
-                        /*PED_DEBUG (0x21, "%d has a superblock copy", i);*/
-			bb = it - 2;
-			ib = it - 1;
-		}
-		else
-		{
-                        /*PED_DEBUG (0x21, "%d doesn't have a superblock copy",
-                            i);*/
-			bb = start;
-			ib = start + 1;
-		}
-
-		if (EXT2_GROUP_BLOCK_BITMAP(fs->gd[i]) != bb ||
-		    EXT2_GROUP_INODE_BITMAP(fs->gd[i]) != ib ||
-		    EXT2_GROUP_INODE_TABLE(fs->gd[i]) != it)
-		{
-		/*	ped_exception_throw (PED_EXCEPTION_NO_FEATURE,
-				PED_EXCEPTION_CANCEL,
-			_("This ext2 file system has a rather strange layout!  "
-			  "Parted can't resize this (yet)."));*/
-
-                 /*       PED_DEBUG (0x21, "calculated block bitmap to be %d, "
-                                         "but fs says %d.", bb,
-                                         EXT2_GROUP_BLOCK_BITMAP(fs->gd[i]));
-                        PED_DEBUG (0x21, "calculated inode bitmap to be %d, "
-                                         "but fs says %d.", ib,
-                                         EXT2_GROUP_INODE_BITMAP(fs->gd[i]));
-                        PED_DEBUG (0x21, "calculated inode table to be %d, "
-                                         "but fs says %d.", it,
-                                         EXT2_GROUP_INODE_TABLE(fs->gd[i]));*/
-                        
-			return 0;
-		}
-	}
-
-	return 1;
-}
-
-int ext2_resize_fs(struct ext2_fs *fs, blk_t newsize, PedTimer* timer)
-{
-	blk_t residue;
-	int status;
-
-	if (EXT2_SUPER_STATE(fs->sb) & EXT2_ERROR_FS)
-	{
-		ped_exception_throw (
-			PED_EXCEPTION_WARNING, PED_EXCEPTION_CANCEL,
-			_("File system has errors!  You should run e2fsck."));
-		return 0;
-	}
-
-	if (!(EXT2_SUPER_STATE(fs->sb) & EXT2_VALID_FS))
-	{
-		ped_exception_throw (
-			PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
-			_("File system was not cleanly unmounted!  "
-			  "You should run e2fsck."));
-		return 0;
-	}
-
-	if (EXT2_SUPER_FEATURE_COMPAT(fs->sb)
-			& EXT2_FEATURE_COMPAT_HAS_DIR_INDEX) {
-		if (ped_exception_throw (
-			PED_EXCEPTION_WARNING, PED_EXCEPTION_IGNORE_CANCEL,
-			_("The file system has the 'dir_index' feature "
-			  "enabled.  Parted can only resize the file system "
-			  "if it disables this feature.  You can enable it "
-			  "later by running 'tune2fs -O dir_index DEVICE' "
-			  "and then 'e2fsck -fD DEVICE'."))
-				!= PED_EXCEPTION_IGNORE)
-			return 0;
-		fs->sb.s_feature_compat
-			= PED_CPU_TO_LE32(EXT2_SUPER_FEATURE_COMPAT(fs->sb)
-					  & ~EXT2_FEATURE_COMPAT_HAS_DIR_INDEX);
-		fs->metadirty |= EXT2_META_SB;
-	}
-
-	if (!ext2_determine_itoffset(fs) && ped_exception_throw (
-                        PED_EXCEPTION_WARNING,
-                        PED_EXCEPTION_OK_CANCEL,
-                        _("A resize operation on this file system will "
-                          "use EXPERIMENTAL code\n"
-                          "that MAY CORRUPT it (although no one has "
-                          "reported any such damage yet).\n"
-                          "You should at least backup your data first, "
-                          "and run 'e2fsck -f' afterwards."))
-                == PED_EXCEPTION_CANCEL)
-        {
-	        return 0;
-        }
-
-	if (fs->opt_verbose)
-                fputs ("ext2_resize_fs\n", stderr);
-
-	residue = (newsize - EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb))
-		   % EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
-	if (residue && residue <= fs->adminblocks)
-		newsize -= residue;
-
-	if (newsize == EXT2_SUPER_BLOCKS_COUNT(fs->sb))
-		return 1;
-
-	fs->relocator_pool
-		= (unsigned char *)ped_malloc(ext2_relocator_pool_size << 10);
-	if (!fs->relocator_pool)
-		return 0;
-	fs->relocator_pool_end
-		= fs->relocator_pool + (ext2_relocator_pool_size << 10);
-
-	if (newsize < EXT2_SUPER_BLOCKS_COUNT(fs->sb))
-		status = ext2_shrink_fs(fs, newsize, timer);
-	else
-		status = ext2_grow_fs(fs, newsize, timer);
-
-	ped_free(fs->relocator_pool);
-	fs->relocator_pool = NULL;
-	fs->relocator_pool_end = NULL;
-
-	return status;
-}
-#endif /* !DISCOVER_ONLY */
