/*
    ext2.c -- generic ext2 stuff
    Copyright (C) 1998, 1999, 2000, 2001, 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 2 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, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
*/

#include <config.h>

#ifndef DISCOVER_ONLY

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <uuid/uuid.h>
#include "ext2.h"

/* ext2 stuff ****************************************************************/

unsigned char _bitmap[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};

int ext2_copy_block(struct ext2_fs *fs, blk_t from, blk_t to)
{
	unsigned char* buf = ped_malloc (fs->blocksize);

	if (!ext2_bcache_flush(fs, from)) return 0;
	if (!ext2_bcache_flush(fs, to)) return 0;

	if (!ext2_read_blocks(fs, buf, from, 1)) return 0;
	if (!ext2_write_blocks(fs, buf, to, 1)) return 0;

	return 1;
}

int ext2_get_block_state(struct ext2_fs *fs, blk_t block)
{
	struct ext2_buffer_head *bh;
	int group;
	int offset;
	int state;

	block -= EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb);
	group = block / EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
	offset = block % EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);

	bh = ext2_bread(fs, EXT2_GROUP_BLOCK_BITMAP(fs->gd[group]));
	state = bh->data[offset>>3] & _bitmap[offset&7];
	ext2_brelse(bh, 0);

	return state;
}

blk_t ext2_find_free_block(struct ext2_fs *fs)
{
	int i;

	for (i=0;i<fs->numgroups;i++)
		if (EXT2_GROUP_FREE_BLOCKS_COUNT(fs->gd[i]))
		{
			blk_t j;
			blk_t offset;

			offset = i * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb)
				 + EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb);
			for (j=fs->adminblocks;
			     j<EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
			     j++)
				if (ext2_is_data_block(fs, offset + j) &&
				    !ext2_get_block_state(fs, offset + j))
					return offset + j;

			ped_exception_throw (PED_EXCEPTION_ERROR,
				PED_EXCEPTION_CANCEL,
				_("Inconsistent group descriptors!"));
		}

	ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
			     _("File system full!"));
	return 0;
}

ino_t ext2_find_free_inode(struct ext2_fs *fs)
{
	int i;

	for (i=0;i<fs->numgroups;i++)
		if (EXT2_GROUP_FREE_INODES_COUNT(fs->gd[i]))
		{
			ino_t j;
			ino_t offset;

			offset = i * EXT2_SUPER_INODES_PER_GROUP(fs->sb) + 1;
			for (j=0;j<EXT2_SUPER_INODES_PER_GROUP(fs->sb);j++)
				if (!ext2_get_inode_state(fs, offset + j))
					return offset + j;

			ped_exception_throw (PED_EXCEPTION_ERROR,
				PED_EXCEPTION_CANCEL,
				_("Inconsistent group descriptors!"));
		}

	ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
			     _("File system full!"));
	return 0;
}

int ext2_move_blocks(struct ext2_fs *fs, blk_t src, blk_t num, blk_t dest)
{
	unsigned char *buf;
	blk_t i;

	ped_exception_fetch_all();
	if ((buf = ped_malloc(num << fs->logsize)) != NULL)
	{
		ped_exception_leave_all();

		if (!ext2_bcache_flush_range(fs, src, num)) return 0;
		if (!ext2_bcache_flush_range(fs, dest, num)) return 0;

		if (!ext2_read_blocks(fs, buf, src, num)) return 0;
		if (!ext2_write_blocks(fs, buf, dest, num)) return 0;

		ped_free(buf);
		return 1;
	}
	ped_exception_catch();
	ped_exception_leave_all();

	if (src > dest)
	{
		for (i=0;i<num;i++)
			if (!ext2_copy_block(fs, src+i, dest+i))
				return 0;
	}
	else
	{
		for (i=num;i>0;i--)
			if (!ext2_copy_block(fs, src+i, dest+i))
				return 0;
	}
	return 1;
}

int ext2_read_blocks(struct ext2_fs *fs, void *ptr, blk_t block, blk_t num)
{
	return fs->devhandle->ops->read(fs->devhandle->cookie, ptr, block, num);
}

int ext2_set_block_state(struct ext2_fs *fs, blk_t block, int state, int updatemetadata)
{
	struct ext2_buffer_head *bh;
	int                      group;
	int                      offset;

	block -= EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb);
	group = block / EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
	offset = block % EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);

	bh = ext2_bread(fs, EXT2_GROUP_BLOCK_BITMAP(fs->gd[group]));
	bh->dirty = 1;
	if (state)
		bh->data[offset>>3] |= _bitmap[offset&7];
	else
		bh->data[offset>>3] &= ~_bitmap[offset&7];
	ext2_brelse(bh, 0);

	if (updatemetadata)
	{
		int diff;

		diff = state ? -1 : 1;

		fs->gd[group].bg_free_blocks_count = PED_CPU_TO_LE16
			(EXT2_GROUP_FREE_BLOCKS_COUNT(fs->gd[group]) + diff);
		fs->sb.s_free_blocks_count = PED_CPU_TO_LE32
			(EXT2_SUPER_FREE_BLOCKS_COUNT(fs->sb) + diff);
		fs->metadirty |= EXT2_META_SB | EXT2_META_GD;
	}
	return 1;
}

int ext2_write_blocks(struct ext2_fs *fs, void *ptr, blk_t block, blk_t num)
{
	return fs->devhandle->ops->write(fs->devhandle->cookie, ptr, block, num);
}

int ext2_zero_blocks(struct ext2_fs *fs, blk_t block, blk_t num)
{
	unsigned char *buf;
	blk_t i;

	ped_exception_fetch_all();
	buf = ped_malloc (num << fs->logsize);
	if (buf)
	{
		ped_exception_leave_all();

		memset(buf, 0, num << fs->logsize);
		if (!ext2_bcache_flush_range(fs, block, num))
			goto error_free_buf;
		if (!ext2_write_blocks(fs, buf, block, num))
			goto error_free_buf;
		ped_free(buf);
		return 1;
	}
	ped_exception_catch();

	buf = ped_malloc (fs->blocksize);
	if (buf)
	{
		ped_exception_leave_all();

		memset(buf, 0, fs->blocksize);

		for (i=0;i<num;i++)
		{
			if (!ext2_bcache_flush(fs, block+i))
				goto error_free_buf;
			if (!ext2_write_blocks(fs, buf, block+i, 1))
				goto error_free_buf;
		}

		ped_free(buf);
		return 1;
	}
	ped_exception_catch();
	ped_exception_leave_all();

	for (i=0;i<num;i++)
	{
		struct ext2_buffer_head *bh;

		bh = ext2_bcreate(fs, block+i);
		if (!bh)
			goto error;
		bh->dirty = 1;
		if (!ext2_brelse(bh, 1))
			goto error;
	}
	return 1;

error_free_buf:
	ped_free(buf);
error:
	return 0;
}

off_t ext2_get_inode_offset(struct ext2_fs *fs, ino_t inode, blk_t *block)
{
	int group;
	int offset;

	inode--;

	group = inode / EXT2_SUPER_INODES_PER_GROUP(fs->sb);
	offset = (inode % EXT2_SUPER_INODES_PER_GROUP(fs->sb))
	       	 * sizeof(struct ext2_inode);

	*block = EXT2_GROUP_INODE_TABLE(fs->gd[group])
	         + (offset >> fs->logsize);

	return offset & (fs->blocksize - 1);
}

int ext2_get_inode_state(struct ext2_fs *fs, ino_t inode)
{
	struct ext2_buffer_head *bh;
	int                      group;
	int                      offset;
	int                      ret;

	inode--;
	group = inode / EXT2_SUPER_INODES_PER_GROUP(fs->sb);
	offset = inode % EXT2_SUPER_INODES_PER_GROUP(fs->sb);

	bh = ext2_bread(fs, EXT2_GROUP_INODE_BITMAP(fs->gd[group]));
	ret = bh->data[offset>>3] & _bitmap[offset&7];
	ext2_brelse(bh, 0);

	return ret;
}

int ext2_read_inode(struct ext2_fs *fs, ino_t inode, struct ext2_inode *data)
{
	struct ext2_buffer_head *bh;
	blk_t			 blk;
	off_t			 off;

	off = ext2_get_inode_offset(fs, inode, &blk);

	bh = ext2_bread(fs, blk);
	if (!bh)
		return 0;

	memcpy(data, bh->data + off, sizeof(struct ext2_inode));
	ext2_brelse(bh, 0);
	return 1;
}

int ext2_set_inode_state(struct ext2_fs *fs, ino_t inode, int state, int updatemetadata)
{
	struct ext2_buffer_head *bh;
	int                      group;
	int                      offset;

	inode--;
	group = inode / EXT2_SUPER_INODES_PER_GROUP(fs->sb);
	offset = inode % EXT2_SUPER_INODES_PER_GROUP(fs->sb);

	bh = ext2_bread(fs, EXT2_GROUP_INODE_BITMAP(fs->gd[group]));
	if (!bh)
		return 0;
	bh->dirty = 1;
	if (state)
		bh->data[offset>>3] |= _bitmap[offset&7];
	else
		bh->data[offset>>3] &= ~_bitmap[offset&7];
	ext2_brelse(bh, 0);

	if (updatemetadata)
	{
		int diff;

		diff = state ? -1 : 1;

		fs->gd[group].bg_free_inodes_count = PED_CPU_TO_LE16
			(EXT2_GROUP_FREE_INODES_COUNT(fs->gd[group]) + diff);
		fs->sb.s_free_inodes_count = PED_CPU_TO_LE32
			(EXT2_SUPER_FREE_INODES_COUNT(fs->sb) + diff);
		fs->metadirty = EXT2_META_SB | EXT2_META_GD;
	}
	return 1;
}

static void
_inode_update_size(struct ext2_fs *fs, struct ext2_inode *inode, int delta)
{
	int		i512perblock = 1 << (fs->logsize - 9);
	uint64_t	size;

	/* i_blocks is in 512 byte blocks */
	inode->i_blocks = PED_CPU_TO_LE32(EXT2_INODE_BLOCKS(*inode)
		       			  + delta * i512perblock);
	size = EXT2_INODE_SIZE(*inode) + delta * fs->blocksize;
	inode->i_size = PED_CPU_TO_LE32(size % (1LL << 32));
	inode->i_size_high = PED_CPU_TO_LE32(size / (1LL << 32));
	inode->i_mtime = PED_CPU_TO_LE32(time(NULL));
}

int ext2_do_inode(struct ext2_fs *fs, struct ext2_inode *inode, blk_t block,
		   int action)
{
	struct ext2_buffer_head *bh;
	uint32_t		*udata;
	blk_t			 count = 0;
	int			 i;
	int			 u32perblock = fs->blocksize >> 2;
	int			 i512perblock = 1 << (fs->logsize - 9);

	if (block == 0 || EXT2_INODE_MODE(*inode) == 0)
		return -1;

	if (fs->opt_debug)
		switch (action)
		{
			case EXT2_ACTION_ADD:
				fprintf(stderr,"adding 0x%04x to inode\n",
					block);
				break;
			case EXT2_ACTION_DELETE:
				fprintf(stderr,"deleting 0x%04x from inode\n",
					block);
				break;
			case EXT2_ACTION_FIND:
				fprintf(stderr,"finding 0x%04x in inode\n",
					block);
				break;
		}

	/* Direct blocks for first 12 blocks */
	for (i = 0; i < EXT2_NDIR_BLOCKS; i++)
	{
		if (action == EXT2_ACTION_ADD && !EXT2_INODE_BLOCK(*inode, i))
		{
			inode->i_block[i] = PED_CPU_TO_LE32(block);
			_inode_update_size (fs, inode, 1);
			ext2_set_block_state(fs, block, 1, 1);
			return i;
		}
		if (EXT2_INODE_BLOCK(*inode, i) == block)
		{
			if (action == EXT2_ACTION_DELETE)
			{
				inode->i_block[i] = 0;
				_inode_update_size (fs, inode, -1);
				ext2_set_block_state(fs, block, 0, 1);
			}
			return i;
		}
		if (EXT2_INODE_BLOCK(*inode, i))
			count += i512perblock;
	}

	count += EXT2_INODE_BLOCK(*inode, EXT2_IND_BLOCK) ? i512perblock : 0;
	count += EXT2_INODE_BLOCK(*inode, EXT2_DIND_BLOCK) ? i512perblock : 0;
	count += EXT2_INODE_BLOCK(*inode, EXT2_TIND_BLOCK) ? i512perblock : 0;

	if (!EXT2_INODE_BLOCK(*inode, EXT2_IND_BLOCK) ||
	    (count >= EXT2_INODE_BLOCKS(*inode) && action != EXT2_ACTION_ADD))
		return -1;

	bh = ext2_bread(fs, EXT2_INODE_BLOCK(*inode, EXT2_IND_BLOCK));
	udata = (uint32_t *)bh->data;

	/* Indirect blocks for next 256/512/1024 blocks (for 1k/2k/4k blocks) */
	for (i = 0; i < u32perblock; i++) {
		if (action == EXT2_ACTION_ADD && !udata[i]) {
			bh->dirty = 1;
			udata[i] = PED_CPU_TO_LE32(block);
			_inode_update_size (fs, inode, 1);
			ext2_set_block_state(fs, block, 1, 1);
			ext2_brelse(bh, 0);
			return EXT2_NDIR_BLOCKS + i;
		}
		if (PED_LE32_TO_CPU(udata[i]) == block) {
			if (action == EXT2_ACTION_DELETE) {
				bh->dirty = 1;
				udata[i] = 0;
				_inode_update_size (fs, inode, -1);
				ext2_set_block_state(fs, block, 0, 1);
			}
			ext2_brelse(bh, 0);
			return EXT2_NDIR_BLOCKS + i;
		}
		if (udata[i])
		{
			count += i512perblock;
			if (count >= EXT2_INODE_BLOCKS(*inode) &&
			    action != EXT2_ACTION_ADD)
				return -1;
		}
	}

	ext2_brelse(bh, 0);

	if (!EXT2_INODE_BLOCK(*inode, EXT2_DIND_BLOCK) ||
	    (count >= EXT2_INODE_BLOCKS(*inode) && action != EXT2_ACTION_ADD))
		return -1;
	bh = ext2_bread(fs, EXT2_INODE_BLOCK(*inode, EXT2_DIND_BLOCK));
	udata = (uint32_t *)bh->data;

	/* Double indirect blocks for next 2^16/2^18/2^20 1k/2k/4k blocks */
	for (i = 0; i < u32perblock; i++) {
		struct ext2_buffer_head	*bh2;
		uint32_t			*udata2;
		int			 j;

		if (!udata[i]) {
			ext2_brelse(bh, 0);
			return -1;
		}
		bh2 = ext2_bread(fs, PED_LE32_TO_CPU(udata[i]));
		udata2 = (uint32_t *)bh2->data;
		count += i512perblock;

		for (j = 0; j < u32perblock; j++) {
			if (action == EXT2_ACTION_ADD && !udata2[j]) {
				bh2->dirty = 1;
				udata2[j] = PED_CPU_TO_LE32(block);
				_inode_update_size (fs, inode, 1);
				ext2_set_block_state(fs, block, 1, 1);
				ext2_brelse(bh, 0);
				ext2_brelse(bh2, 0);
				return EXT2_NDIR_BLOCKS + i * u32perblock + j;
			}
			if (PED_LE32_TO_CPU(udata2[j]) == block) {
				if (action == EXT2_ACTION_DELETE) {
					bh2->dirty = 1;
					udata2[j] = 0;
					_inode_update_size (fs, inode, -1);
					ext2_set_block_state(fs, block, 0, 1);
				}
				ext2_brelse(bh, 0);
				ext2_brelse(bh2, 0);
				return EXT2_NDIR_BLOCKS + i * u32perblock + j;
			}
			if (udata2[j])
			{
				count += i512perblock;
				if (count >= EXT2_INODE_BLOCKS(*inode) &&
				    action != EXT2_ACTION_ADD)
					return -1;
			}
		}
		ext2_brelse(bh2, 0);
	}
	ext2_brelse(bh, 0);

	/* FIXME: we should check for triple-indirect blocks here, but it
	 * would be nice to have a better routine to traverse blocks, and
	 * file systems that need triple-indirect blocks for the resize
	 * inode are too big to worry about yet.
	 */

	return -1;
}

int ext2_write_inode(struct ext2_fs *fs, ino_t inode, const struct ext2_inode *data)
{
	struct ext2_buffer_head *bh;
	blk_t			 blk;
	off_t			 off;

	off = ext2_get_inode_offset(fs, inode, &blk);

	bh = ext2_bread(fs, blk);
	if (!bh)
		return 0;
	bh->dirty = 1;
	memcpy(bh->data + off, data, sizeof(struct ext2_inode));
	ext2_brelse(bh, 0);

	return 1;
}

int ext2_zero_inode(struct ext2_fs *fs, ino_t inode)
{
	struct ext2_inode buf;

	memset(&buf, 0, sizeof(struct ext2_inode));
	return ext2_write_inode(fs, inode, &buf);
}


/* check whether y is root of x
 * (formula grabbed from linux ext2 kernel source) */
static int is_root(int x, int y)
{
	if (!x)
		return 1;

	while (1)
	{
		if (x == 1)
			return 1;

		if (x % y)
			return 0;

		x /= y;
	}
}

/* check whether group contains a superblock copy on file systems
 * where not all groups have one (sparse superblock feature) */
int ext2_is_group_sparse(struct ext2_fs *fs, int group)
{       
	if (!fs->sparse)
		return 1;

	if (is_root(group, 3) || is_root(group, 5) || is_root(group, 7))
		return 1;

	return 0;
}

void ext2_close(struct ext2_fs *fs)
{
	ext2_commit_metadata(fs, EXT2_META_PRIMARY | EXT2_META_BACKUP);
	ext2_sync(fs);

	ext2_bcache_deinit(fs);

	fs->devhandle->ops->close(fs->devhandle->cookie);

	ped_free(fs->gd);
	ped_free(fs);
}

int ext2_commit_metadata(struct ext2_fs *fs, int copies)
{
	int		i;
	int		num;
	int		wmeta = fs->metadirty & copies;
	unsigned char*	sb = ped_malloc(fs->blocksize);
	struct ext2_super_block *sb_for_io;
	int		sb_block;

	/* See if there is even anything to write... */
	if (wmeta == EXT2_META_CLEAN)
		return 1;

	fs->sb.s_r_blocks_count = PED_CPU_TO_LE32 (
		fs->r_frac * (loff_t)EXT2_SUPER_BLOCKS_COUNT(fs->sb)
				  / 100);

	if (!ext2_read_blocks (fs, sb, 0, 1))
		return 0;

	if (EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb)) {
		memcpy(sb, &fs->sb, 1024);
		sb_for_io = (struct ext2_super_block *) sb;
	} else {
		memcpy(sb+1024, &fs->sb, 1024);
		sb_for_io = (struct ext2_super_block *) (sb + 1024);
	}

	num = copies & EXT2_META_BACKUP ? fs->numgroups : 1;

	for (i = 0, sb_block = EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb); i < num;
	     i++, sb_block += EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb))
	{

		if (!ext2_is_group_sparse(fs, i))
			continue;

		if (fs->dynamic_version)
			sb_for_io->s_block_group_nr = PED_CPU_TO_LE16 (i);

		if ((i == 0 && wmeta & EXT2_META_PRIMARY_SB) ||
		    (i != 0 && wmeta & EXT2_META_SB))
		{
			if (!ext2_bcache_flush_range(fs, sb_block, 1))
				return 0;
			if (!ext2_write_blocks(fs, sb, sb_block, 1))
				return 0;
		}
		if ((i == 0 && wmeta & EXT2_META_PRIMARY_GD) ||
		    (i != 0 && wmeta & EXT2_META_GD))
		{
			if (!ext2_bcache_flush_range(fs, sb_block + 1,
						     fs->gdblocks))
				return 0;
			if (!ext2_write_blocks(fs, fs->gd, sb_block + 1,
					       fs->gdblocks))
				return 0;
		}
	}

	sb_for_io->s_block_group_nr = 0;

	/* Clear the flags of the components we just finished writing. */
	fs->metadirty &= ~copies;

	return 1;
}

int ext2_sync(struct ext2_fs *fs)
{
	if (!ext2_commit_metadata(fs, EXT2_META_PRIMARY)) return 0;
	if (!ext2_bcache_sync(fs)) return 0;
	if (!fs->devhandle->ops->sync(fs->devhandle->cookie)) return 0;
	return 1;
}

struct ext2_fs *ext2_open(struct ext2_dev_handle *handle, int state)
{
	struct ext2_fs *fs;

	if ((fs = (struct ext2_fs *) ped_malloc(sizeof(struct ext2_fs)))
		== NULL)
		goto error;

	handle->ops->set_blocksize(handle->cookie, 10);

	if (!handle->ops->read(handle->cookie, &fs->sb, 1, 1)
	    || EXT2_SUPER_MAGIC(fs->sb) != EXT2_SUPER_MAGIC_CONST)
	{
		ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
			_("Invalid superblock.  Are you sure this is an ext2 "
			  "file system?"));
		goto error_free_fs;
	}


	fs->opt_debug = 1;
	fs->opt_safe = 1;
	fs->opt_verbose = 0;

	if (EXT2_SUPER_STATE(fs->sb) & EXT2_ERROR_FS & ~(state & EXT2_ERROR_FS))
	{
		if (ped_exception_throw (
			PED_EXCEPTION_WARNING, PED_EXCEPTION_IGNORE_CANCEL,
			_("File system has errors!  You should run e2fsck."))
				== PED_EXCEPTION_CANCEL)
			goto error_free_fs;
	}

	if (!((EXT2_SUPER_STATE(fs->sb) | state) & EXT2_VALID_FS)
	    || (EXT2_SUPER_FEATURE_INCOMPAT(fs->sb)
		& EXT3_FEATURE_INCOMPAT_RECOVER))
	{
		if (ped_exception_throw (
			PED_EXCEPTION_ERROR, PED_EXCEPTION_IGNORE_CANCEL,
			_("File system was not cleanly unmounted!  "
			  "You should run e2fsck.  Modifying an unclean "
			  "file system could cause severe corruption."))
				!= PED_EXCEPTION_IGNORE)
			goto error_free_fs;
	}

	fs->dynamic_version = EXT2_SUPER_REV_LEVEL (fs->sb) > 0;

	if ((EXT2_SUPER_FEATURE_COMPAT(fs->sb)
	                & ~(EXT3_FEATURE_COMPAT_HAS_JOURNAL |
			    EXT2_FEATURE_COMPAT_HAS_DIR_INDEX)) ||
	    (EXT2_SUPER_FEATURE_INCOMPAT(fs->sb)
	    		& ~(EXT2_FEATURE_INCOMPAT_FILETYPE |
			    EXT3_FEATURE_INCOMPAT_RECOVER)) ||
	    (EXT2_SUPER_FEATURE_RO_COMPAT(fs->sb)
			& ~(EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER |
			    EXT2_FEATURE_RO_COMPAT_LARGE_FILE)))
	{
		ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
		     _("File system has an incompatible feature enabled."));
		goto error_free_fs;
	}

	fs->devhandle = handle;
	fs->logsize = EXT2_SUPER_LOG_BLOCK_SIZE(fs->sb) + 10;
	handle->ops->set_blocksize(handle->cookie, fs->logsize);

	if (!ext2_bcache_init(fs))
	{
		ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
				     _("Error allocating buffer cache."));
		goto error_free_fs;
	}

	fs->blocksize = 1 << fs->logsize;

	fs->numgroups = ped_div_round_up (EXT2_SUPER_BLOCKS_COUNT(fs->sb)
		       		- EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb),
				EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb));
	fs->gdblocks = ped_div_round_up (fs->numgroups
                        * sizeof(struct ext2_group_desc),
			       fs->blocksize);
	fs->inodeblocks = ped_div_round_up (EXT2_SUPER_INODES_PER_GROUP(fs->sb)
		       		  * sizeof(struct ext2_inode),
				  fs->blocksize);
	fs->r_frac = ped_div_round_up (100 * (loff_t)EXT2_SUPER_R_BLOCKS_COUNT(fs->sb),
		       	     EXT2_SUPER_BLOCKS_COUNT(fs->sb));
	fs->adminblocks = 3 + fs->gdblocks + fs->inodeblocks;

	fs->sparse = 0;
	if (EXT2_SUPER_FEATURE_RO_COMPAT(fs->sb)
			& EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER)
		fs->sparse = 1;

	fs->has_journal = 0 < (EXT2_SUPER_FEATURE_COMPAT(fs->sb)
			       & EXT3_FEATURE_COMPAT_HAS_JOURNAL);
	fs->has_internal_journal
		= fs->has_journal
			&& uuid_is_null(EXT2_SUPER_JOURNAL_UUID(fs->sb))
			&& EXT2_SUPER_JOURNAL_INUM(fs->sb);

	fs->gd = ped_malloc (fs->numgroups * sizeof (struct ext2_group_desc)
			     	+ fs->blocksize);
	if (!fs->gd)
		goto error_deinit_bcache;

	ext2_read_blocks(fs, fs->gd, EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb) + 1,
			 fs->gdblocks);
                
	fs->metadirty = 0;
	return fs;

	ped_free(fs->gd);
error_deinit_bcache:
	ext2_bcache_deinit(fs);
error_free_fs:
	ped_free(fs);
error:
	return NULL;
}

#endif /* !DISCOVER_ONLY */