--- old/usr/src/lib/libparted/common/libparted/fs/ext2/ext2_mkfs.c	2014-07-17 16:13:49.069696632 +0200
+++ /dev/null	2014-07-17 16:13:49.000000000 +0200
@@ -1,632 +0,0 @@
-/*
-    ext2_mkfs.c -- ext2 fs creator
-    Copyright (C) 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 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
-
-#define USE_EXT2_IS_DATA_BLOCK
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <time.h>
-#include <unistd.h>
-#include <uuid/uuid.h>
-#include "ext2.h"
-
-/* formula grabbed from linux ext2 kernel source
- * 
- * returns 1 iff:
- * 	x == y^N,       N is some natural number
- * OR	x == 0
- */
-static __inline__ 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;
-	}
-}
-
-static __inline__ int is_group_sparse(int sparsesbfs, int group)
-{
-	if (!sparsesbfs)
-		return 1;
-
-	if (is_root(group, 3) || is_root(group, 5) || is_root(group, 7))
-		return 1;
-
-	return 0;
-}
-
-/* has implicit parameter 'sb' !! */
-#define is_sparse(group) is_group_sparse(EXT2_SUPER_FEATURE_RO_COMPAT(*sb) \
-	       			& EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER, (group))
-
-static int ext2_mkfs_write_main(struct ext2_dev_handle *handle,
-				struct ext2_super_block *sb,
-				struct ext2_group_desc *gd)
-{
-	int freeit;
-	int i;
-	int numgroups;
-	int gdblocks;
-	unsigned char *sbbuf;
-	struct ext2_super_block *sb_for_io;
-
-	freeit = 0;
-	sbbuf = (unsigned char *)sb;
-	sb_for_io = sb;
-	if (EXT2_SUPER_LOG_BLOCK_SIZE(*sb))
-	{
-		sbbuf = ped_malloc(1024 << EXT2_SUPER_LOG_BLOCK_SIZE(*sb));
-		if (!(handle->ops->read)(handle->cookie, sbbuf, 0, 1))
-			return 0;
-		memcpy (sbbuf+1024, sb, 1024);
-		freeit = 1;
-		sb_for_io = (struct ext2_super_block*) (sbbuf + 1024);
-	}
-
-	numgroups = ped_div_round_up (EXT2_SUPER_BLOCKS_COUNT(*sb)
-			        - EXT2_SUPER_FIRST_DATA_BLOCK(*sb),
-			    EXT2_SUPER_BLOCKS_PER_GROUP(*sb));
-	gdblocks = ped_div_round_up (numgroups * sizeof(struct ext2_group_desc),
-			   1024 << EXT2_SUPER_LOG_BLOCK_SIZE(*sb));
-
-	for (i=0;i<numgroups;i++)
-	{
-		if (is_sparse(i))
-		{
-			int offset;
-
-			offset = EXT2_SUPER_FIRST_DATA_BLOCK(*sb)
-				 + i * EXT2_SUPER_BLOCKS_PER_GROUP(*sb);
-
-			sb_for_io->s_block_group_nr = PED_CPU_TO_LE16 (i);
-
-			if (!handle->ops->write(handle->cookie, sbbuf,
-					        offset, 1))
-				return 0;
-			if (!handle->ops->write(handle->cookie, gd, offset+1,
-						gdblocks))
-				return 0;
-		}
-	}
-
-	sb_for_io->s_block_group_nr = 0;
-
-	if (freeit)
-		ped_free(sbbuf);
-	return 1;
-}
-
-static int ext2_mkfs_write_meta(struct ext2_dev_handle *handle,
-				struct ext2_super_block *sb,
-				struct ext2_group_desc *gd,
-				PedTimer* timer)
-{
-	int blocksize;
-	int gdtsize;
-	int i;
-	int itsize;
-	int numgroups;
-	unsigned char *bb;
-	unsigned char *ib;
-	unsigned char *zero;
-
-	blocksize = 1 << (EXT2_SUPER_LOG_BLOCK_SIZE(*sb) + 13);
-
-	numgroups = ped_div_round_up (EXT2_SUPER_BLOCKS_COUNT(*sb)
-				- EXT2_SUPER_FIRST_DATA_BLOCK(*sb),
-			    EXT2_SUPER_BLOCKS_PER_GROUP(*sb));
-	itsize = ped_div_round_up (sizeof(struct ext2_inode)
-				* EXT2_SUPER_INODES_PER_GROUP(*sb),
-			 (1024 << EXT2_SUPER_LOG_BLOCK_SIZE(*sb)));
-	gdtsize = ped_div_round_up (sizeof(struct ext2_group_desc) * numgroups,
-			  (1024 << EXT2_SUPER_LOG_BLOCK_SIZE(*sb)));
-
-	bb = ped_malloc(1024 << EXT2_SUPER_LOG_BLOCK_SIZE(*sb));
-	if (!bb) goto error;
-	ib = ped_malloc(1024 << EXT2_SUPER_LOG_BLOCK_SIZE(*sb));
-	if (!ib) goto error_free_bb;
-	zero = ped_malloc((1024 << EXT2_SUPER_LOG_BLOCK_SIZE(*sb)) * itsize);
-	if (!zero) goto error_free_zero;
-
-	memset(zero, 0, (1024 << EXT2_SUPER_LOG_BLOCK_SIZE(*sb)) * itsize);
-
-	ped_timer_reset (timer);
-	ped_timer_set_state_name (timer, _("writing per-group metadata"));
-
-	for (i=0;i<numgroups;i++)
-	{
-		int admin;
-		blk_t bbblock;
-		int groupsize;
-		int groupoffset;
-		blk_t ibblock;
-		int j;
-
-		ped_timer_update (timer, 1.0 * i / numgroups);
-
-		groupoffset = i*EXT2_SUPER_BLOCKS_PER_GROUP(*sb)
-			      + EXT2_SUPER_FIRST_DATA_BLOCK(*sb);
-		groupsize = PED_MIN(EXT2_SUPER_BLOCKS_COUNT(*sb) - groupoffset,
-				    EXT2_SUPER_BLOCKS_PER_GROUP(*sb));
-
-		admin = itsize + 2;
-		bbblock = groupoffset;
-		ibblock = groupoffset + 1;
-		if (is_sparse(i))
-		{
-			admin += gdtsize + 1;
-			bbblock = groupoffset + gdtsize + 1;
-			ibblock = groupoffset + gdtsize + 2;
-		}
-
-		{
-			memset(bb, 0, 1024 << EXT2_SUPER_LOG_BLOCK_SIZE(*sb));
-			if (is_sparse(i))
-				for (j=0;j<gdtsize+1;j++)
-					bb[j>>3] |= _bitmap[j&7];
-
-			j = bbblock - groupoffset;
-			bb[j>>3] |= _bitmap[j&7];
-
-			j = ibblock - groupoffset;
-			bb[j>>3] |= _bitmap[j&7];
-
-			for (j=0;j<itsize;j++)
-			{
-				int k = j + gdtsize + 3;
-
-				bb[k>>3] |= _bitmap[k&7];
-			}
-
-			for (j=groupsize;j<blocksize;j++)
-				bb[j>>3] |= _bitmap[j&7];
-
-			if (!handle->ops->write(handle->cookie, bb, bbblock, 1))
-				goto error_free_zero;
-		}
-
-		{
-			memset(ib, 0, 1024 << EXT2_SUPER_LOG_BLOCK_SIZE(*sb));
-
-			for (j=EXT2_SUPER_INODES_PER_GROUP(*sb);j<blocksize;j++)
-				bb[j>>3] |= _bitmap[j&7];
-
-			if (!handle->ops->write(handle->cookie, ib, ibblock, 1))
-				goto error_free_zero;
-		}
-
-		if (!handle->ops->write(handle->cookie, zero,
-					groupoffset + gdtsize + 3, itsize))
-			goto error_free_zero;
-
-		gd[i].bg_block_bitmap = PED_CPU_TO_LE32(bbblock);
-		gd[i].bg_inode_bitmap = PED_CPU_TO_LE32(ibblock);
-		gd[i].bg_inode_table = PED_CPU_TO_LE32(groupoffset + gdtsize
-						       + 3);
-		gd[i].bg_free_blocks_count = PED_CPU_TO_LE16(groupsize - admin);
-		gd[i].bg_free_inodes_count = PED_CPU_TO_LE16(
-			EXT2_SUPER_INODES_PER_GROUP(*sb));
-		gd[i].bg_used_dirs_count = 0;
-		gd[i].bg_used_dirs_count = 0;
-		gd[i].bg_pad = 0;
-		gd[i].bg_reserved[0] = 0;
-		gd[i].bg_reserved[1] = 0;
-		gd[i].bg_reserved[2] = 0;
-
-		sb->s_free_blocks_count = PED_CPU_TO_LE32 (
-			EXT2_SUPER_FREE_BLOCKS_COUNT(*sb)
-			+ EXT2_GROUP_FREE_BLOCKS_COUNT(gd[i]));
-	}
-
-	ped_timer_update (timer, 1.0);
-
-	ped_free(zero);
-	ped_free(ib);
-	ped_free(bb);
-	return 1;
-
-error_free_zero:
-	ped_free(zero);
-	ped_free(ib);
-error_free_bb:
-	ped_free(bb);
-error:
-	return 0;
-}
-
-/* returns the offset into the buffer of the start of the next dir entry */
-static int _set_dirent(void* buf, int offset, int block_size, int is_last,
-		       uint32_t inode, char* name, int file_type)
-{
-	struct ext2_dir_entry_2 *dirent = (void*) (((char*)buf) + offset);
-	int name_len = strlen(name);
-	int rec_len;
-
-	if (is_last)
-		rec_len = block_size - offset;
-	else
-		rec_len = ped_round_up_to(name_len + 1 + 8, 4);
-
-	memset (dirent, 0, rec_len);
-
-	dirent->inode = PED_CPU_TO_LE32(inode);
-	dirent->name_len = name_len;
-	dirent->rec_len = PED_CPU_TO_LE16(rec_len);
-	dirent->file_type = file_type;
-	strcpy(dirent->name, name);
-
-	return offset + rec_len;
-}
-
-static int ext2_mkfs_create_lost_and_found_inode(struct ext2_fs *fs)
-{
-	struct ext2_buffer_head *bh;
-	blk_t blocks[12];
-	uint32_t* data = ped_malloc ((fs->blocksize / 4) * sizeof(uint32_t));
-	int i;
-	struct ext2_inode inode;
-	int offset;
-
-	for (i=0;i<12;i++)
-	{
-		if (!(blocks[i] = ext2_find_free_block(fs)))
-			return 0;
-
-		if (!ext2_set_block_state(fs, blocks[i], 1, 1))
-			return 0;
-	}
-
-	/* create the directory entries, preallocating lots of blocks */
-	/* first block contains . and .. */
-	bh = ext2_bcreate(fs, blocks[0]);
-	if (!bh)
-		return 0;
-	memset(bh->data, 0, fs->blocksize);
-	offset = _set_dirent(bh->data, 0, fs->blocksize, 0,
-			     11, ".", EXT2_FT_DIR);
-	offset = _set_dirent(bh->data, offset, fs->blocksize, 1,
-			     EXT2_ROOT_INO, "..", EXT2_FT_DIR);
-	bh->dirty = 1;
-	ext2_brelse(bh, 1);
-
-	/* subsequent blocks are empty */
-	memset(data, 0, fs->blocksize);
-	data[0] = 0;
-	data[1] = PED_CPU_TO_LE32(fs->blocksize);
-	for (i=1;i<12;i++)
-	{
-		bh = ext2_bcreate(fs, blocks[i]);
-		memcpy(bh->data, data, fs->blocksize);
-		bh->dirty = 1;
-		ext2_brelse(bh, 1);
-	}
-
-	/* create inode */
-	memset(&inode, 0, sizeof(struct ext2_inode));
-	inode.i_mode = PED_CPU_TO_LE16(S_IFDIR | 0755);
-	inode.i_uid = 0;
-	inode.i_size = PED_CPU_TO_LE32(12 * fs->blocksize);
-	inode.i_atime = PED_CPU_TO_LE32(time(NULL));
-	inode.i_ctime = PED_CPU_TO_LE32(time(NULL));
-	inode.i_mtime = PED_CPU_TO_LE32(time(NULL));
-	inode.i_dtime = 0;
-	inode.i_gid = 0;
-	inode.i_links_count = PED_CPU_TO_LE16(2);
-	inode.i_blocks = PED_CPU_TO_LE32((12 * fs->blocksize) >> 9);
-	inode.i_flags = 0;
-	for (i=0;i<12;i++)
-		inode.i_block[i] = PED_CPU_TO_LE32(blocks[i]);
-
-	if (!ext2_write_inode(fs, 11, &inode))
-		return 0;
-	fs->gd[0].bg_used_dirs_count = PED_CPU_TO_LE16(
-		EXT2_GROUP_USED_DIRS_COUNT(fs->gd[0]) + 1);
-	fs->metadirty |= EXT2_META_GD;
-
-	return 1;
-}
-
-static int ext2_mkfs_create_root_inode(struct ext2_fs *fs)
-{
-	struct ext2_buffer_head *bh;
-	blk_t block;
-	struct ext2_inode inode;
-	int offset;
-
-	if (!(block = ext2_find_free_block(fs)))
-		return 0;
-	if (!ext2_set_block_state(fs, block, 1, 1))
-		return 0;
-
-	/* create directory entries */
-	bh = ext2_bcreate(fs, block);
-	memset(bh->data, 0, fs->blocksize);
-	offset = _set_dirent(bh->data, 0, fs->blocksize, 0,
-			     EXT2_ROOT_INO, ".", EXT2_FT_DIR);
-	offset = _set_dirent(bh->data, offset, fs->blocksize, 0,
-			     EXT2_ROOT_INO, "..", EXT2_FT_DIR);
-	offset = _set_dirent(bh->data, offset, fs->blocksize, 1,
-			     11, "lost+found", EXT2_FT_DIR);
-	bh->dirty = 1;
-	if (!ext2_brelse(bh, 1))
-		return 0;
-
-	/* create inode */
-	memset(&inode, 0, sizeof(struct ext2_inode));
-	inode.i_mode = PED_CPU_TO_LE16(S_IFDIR | 0755);
-	inode.i_uid = 0;
-	inode.i_size = PED_CPU_TO_LE32(fs->blocksize);
-	inode.i_atime = PED_CPU_TO_LE32(time(NULL));
-	inode.i_ctime = PED_CPU_TO_LE32(time(NULL));
-	inode.i_mtime = PED_CPU_TO_LE32(time(NULL));
-	inode.i_dtime = 0;
-	inode.i_gid = 0;
-	inode.i_links_count = PED_CPU_TO_LE16(3);
-	inode.i_blocks = PED_CPU_TO_LE32(fs->blocksize >> 9);
-	inode.i_flags = 0;
-	inode.i_block[0] = PED_CPU_TO_LE32(block);
-
-	if (!ext2_write_inode(fs, 2, &inode))
-		return 0;
-	fs->gd[0].bg_used_dirs_count = PED_CPU_TO_LE16 (
-		EXT2_GROUP_USED_DIRS_COUNT(fs->gd[0]) + 1);
-	fs->metadirty |= EXT2_META_GD;
-
-	return 1;
-}
-
-static int ext2_reserve_inodes(struct ext2_fs *fs)
-{
-	int i;
-
-	for (i=1;i<12;i++)
-		if (!ext2_set_inode_state(fs, i, 1, 1))
-			return 0;
-	return 1;
-}
-
-static int ext2_mkfs_init_sb (struct ext2_super_block *sb, blk_t numblocks,
-			      int numgroups, int first_block,
-			      int log_block_size, blk_t blocks_per_group,
-			      int inodes_per_group, int sparse_sb,
-			      int reserved_block_percentage)
-{
-	/* catch a bug in gcc 2.95.2 */
-	PED_ASSERT(numgroups != 0, return 0);
-
-	memset(sb, 0, 1024);
-
-	sb->s_inodes_count = PED_CPU_TO_LE32(numgroups * inodes_per_group);
-	sb->s_blocks_count = PED_CPU_TO_LE32(numblocks);
-	sb->s_r_blocks_count = PED_CPU_TO_LE32(((uint64_t)numblocks
-				* reserved_block_percentage) / 100);
-
-	/* hack: this get's inc'd as we go through each group in
-	 * ext2_mkfs_write_meta()
-	 */
-	sb->s_free_blocks_count = 0;
-	sb->s_free_inodes_count = PED_CPU_TO_LE32 (numgroups
-							* inodes_per_group);
-	sb->s_first_data_block = PED_CPU_TO_LE32(first_block);
-	sb->s_log_block_size = PED_CPU_TO_LE32(log_block_size - 10);
-	sb->s_log_frag_size = sb->s_log_block_size;
-	sb->s_blocks_per_group = PED_CPU_TO_LE32(blocks_per_group);
-	sb->s_frags_per_group = PED_CPU_TO_LE32(blocks_per_group);
-	sb->s_inodes_per_group = PED_CPU_TO_LE32(inodes_per_group);
-	sb->s_mtime = 0;
-	sb->s_wtime = 0;
-	sb->s_mnt_count = 0;
-	sb->s_max_mnt_count = PED_CPU_TO_LE16(30);
-	sb->s_magic = PED_CPU_TO_LE16(0xEF53);
-	sb->s_state = PED_CPU_TO_LE16(EXT2_VALID_FS);
-	sb->s_errors = PED_CPU_TO_LE16(EXT2_ERRORS_DEFAULT);
-	sb->s_minor_rev_level = 0;
-	sb->s_lastcheck = 0;
-	sb->s_checkinterval = 0;
-	sb->s_creator_os = 0;
-	sb->s_rev_level = PED_CPU_TO_LE32(1);
-	sb->s_def_resuid = 0;
-	sb->s_def_resgid = 0;
-	sb->s_first_ino = PED_CPU_TO_LE32(11);
-	sb->s_inode_size = PED_CPU_TO_LE16(128);
-	sb->s_block_group_nr = 0;
-	sb->s_feature_compat = 0;
-	sb->s_feature_incompat = 0;
-	sb->s_feature_ro_compat = 0;
-	if (sparse_sb)
-		sb->s_feature_ro_compat
-			|= PED_CPU_TO_LE32(EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER);
-
-/* FIXME: let the user decide? _set_dirent() assumes FILETYPE */
-	sb->s_feature_incompat
-		|= PED_CPU_TO_LE32(EXT2_FEATURE_INCOMPAT_FILETYPE);
-
-	uuid_generate(sb->s_uuid);
-	memset(sb->s_volume_name, 0, 16);
-	memset(sb->s_last_mounted, 0, 64);
-	sb->s_algorithm_usage_bitmap = 0;
-	sb->s_prealloc_blocks = 0;
-	sb->s_prealloc_dir_blocks = 0;
-	sb->s_padding1 = 0;
-
-	return 1;
-}
-
-/* Given these five inputs, compute the three outputs.  */
-static void
-compute_block_counts (blk_t numblocks, int numgroups, int log_block_size,
-                      int sparse_sb, blk_t blocks_per_group,
-                      int *last_group_blocks,
-                      int *last_group_admin,
-                      int *inodes_per_group)
-{
-        int first_block = (log_block_size == 10) ? 1 : 0;
-        size_t block_size = 1 << log_block_size;
-
-        *last_group_blocks = ((numblocks - first_block) % blocks_per_group);
-        if (!*last_group_blocks)
-                *last_group_blocks = blocks_per_group;
-        *inodes_per_group = ped_round_up_to (numblocks / numgroups / 2,
-                                             (block_size
-                                              / sizeof(struct ext2_inode)));
-        *last_group_admin = (2 + *inodes_per_group * sizeof(struct ext2_inode)
-                             / block_size);
-        if (is_group_sparse(sparse_sb, numgroups - 1)) {
-                *last_group_admin +=
-                  (ped_div_round_up (numgroups * sizeof(struct ext2_group_desc),
-                                     block_size));
-        }
-}
-
-struct ext2_fs *ext2_mkfs(struct ext2_dev_handle *handle,
-			  blk_t numblocks,
-			  int log_block_size,
-			  blk_t blocks_per_group,
-			  int inodes_per_group,
-			  int sparse_sb,
-			  int reserved_block_percentage,
-			  PedTimer* timer)
-{
-	struct ext2_fs *fs;
-	struct ext2_super_block sb;
-	struct ext2_group_desc *gd;
-	int numgroups;
-	int first_block;
-	int last_group_blocks;
-	int last_group_admin;
-        
-	/* if the FS is > 512Mb, use 4k blocks, otherwise 1k blocks */
-	if (log_block_size == 0) {
-		handle->ops->set_blocksize(handle->cookie, 12);
-		if (handle->ops->get_size(handle->cookie) > (512 * 1024))
-			log_block_size = 12;
-		else
-			log_block_size = 10;
-	}
-
-        /* FIXME: block size must be > MAX(logicalbs, physicalbs)
-         * to avoid modify-on-write.
-         *      -- Leslie
-         */ 
-
-        
-	handle->ops->set_blocksize(handle->cookie, log_block_size);
-
-	if (numblocks == 0)
-		numblocks = handle->ops->get_size(handle->cookie);
-        if (numblocks == 0)
-                goto diagnose_fs_too_small;
-
-	if (blocks_per_group == (unsigned int) 0)
-		blocks_per_group = 8 << log_block_size;
-
-	first_block = (log_block_size == 10) ? 1 : 0;
-
-	numgroups = ped_div_round_up (numblocks
-                        - first_block, blocks_per_group);
-
-	if (sparse_sb == -1)
-		sparse_sb = 1;
-
-        /* FIXME: 5% not appropriate for modern drive sizes */
-	if (reserved_block_percentage == -1)
-		reserved_block_percentage = 5;
-
-        compute_block_counts (numblocks, numgroups, log_block_size, sparse_sb,
-                              blocks_per_group, &last_group_blocks,
-                              &last_group_admin, &inodes_per_group);
-
-	int fs_too_small = 0;
-	if (last_group_admin + 1 >= last_group_blocks)
-          {
-            numgroups--;
-            if (numgroups == 0)
-              fs_too_small = 1;
-            else
-              {
-		numblocks -= last_group_blocks;
-                compute_block_counts (numblocks, numgroups, log_block_size,
-                                      sparse_sb, blocks_per_group,
-                                      &last_group_blocks, &last_group_admin,
-                                      &inodes_per_group);
-              }
-          }
-
-        if (numgroups == 1
-            && (last_group_blocks - last_group_admin < 8
-                || inodes_per_group < 16
-                /* This final term ensures that we detect
-                   mkpartfs primary ext2 10KB 27650B as invalid.  */
-                || (inodes_per_group == 16
-                    && last_group_blocks - last_group_admin < 14)))
-          fs_too_small = 1;
-
-	if (fs_too_small) {
-	diagnose_fs_too_small:
-		ped_exception_throw (
-			PED_EXCEPTION_ERROR,
-			PED_EXCEPTION_CANCEL,
-			_("File system too small for ext2."));
-		goto error;
-	}
-
-	gd = ped_malloc(numgroups * sizeof(struct ext2_group_desc)
-			+ (1 << log_block_size));
-	if (!gd)
-		goto error;
-
-	if (!ext2_mkfs_init_sb(&sb, numblocks, numgroups, first_block,
-			       log_block_size, blocks_per_group,
-			       inodes_per_group, sparse_sb,
-			       reserved_block_percentage))
-       		goto error_free_gd;
-	if (!ext2_mkfs_write_meta(handle, &sb, gd, timer))
-       		goto error_free_gd;
-	if (!ext2_mkfs_write_main(handle, &sb, gd))
-       		goto error_free_gd;
-
-	fs = ext2_open(handle, 0);
-	if (!fs) goto error_close_fs;
-	if (!ext2_reserve_inodes(fs)) goto error_close_fs;
-	if (!ext2_mkfs_create_root_inode(fs)) goto error_close_fs;
-	if (!ext2_mkfs_create_lost_and_found_inode(fs))
-		goto error_close_fs;
-	if (!ext2_sync(fs)) goto error_close_fs;
-	ped_free(gd);
-	return fs;
-
-error_close_fs:
-	ext2_close(fs);
-error_free_gd:
-	ped_free (gd);
-error:
-	return NULL;
-}
-#endif /* !DISCOVER_ONLY */
