X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=misc%2Fmke2fs.c;h=0004c012ab1b42d2bdbbc2d9ce3b999fb542b599;hb=abcfdfda7a5932cbb27ff243ed962119db2599a4;hp=23e92b4460e9b4ab1d2d7fd0bac517b8c859f128;hpb=e294cf2f6409aeede04316b1268f3e78a83509d0;p=tools%2Fe2fsprogs.git

diff --git a/misc/mke2fs.c b/misc/mke2fs.c
index 23e92b4..0004c01 100644
--- a/misc/mke2fs.c
+++ b/misc/mke2fs.c
@@ -1,7 +1,8 @@
 /*
  * mke2fs.c - Make a ext2fs filesystem.
  * 
- * Copyright (C) 1994, 1995, 1996, 1997 Theodore Ts'o.
+ * Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+ * 	2003, 2004, 2005 by Theodore Ts'o.
  *
  * %Begin-Header%
  * This file may be redistributed under the terms of the GNU Public
@@ -20,7 +21,7 @@
 #include <fcntl.h>
 #include <ctype.h>
 #include <time.h>
-#ifdef linux
+#ifdef __linux__
 #include <sys/utsname.h>
 #endif
 #ifdef HAVE_GETOPT_H
@@ -44,22 +45,16 @@ extern int optind;
 #include <sys/ioctl.h>
 #include <sys/types.h>
 
-#include <linux/ext2_fs.h>
-#ifdef HAVE_LINUX_MAJOR_H
-#include <linux/major.h>
-#include <sys/stat.h>		/* Only need sys/stat.h for major nr test */
-#endif
-
+#include "ext2fs/ext2_fs.h"
 #include "et/com_err.h"
 #include "uuid/uuid.h"
 #include "e2p/e2p.h"
 #include "ext2fs/ext2fs.h"
+#include "util.h"
+#include "profile.h"
 #include "../version.h"
 #include "nls-enable.h"
 
-/* Everything is STDC, these days */
-#define NOARGS void
-
 #define STRIDE_LENGTH 8
 
 #ifndef __sparc__
@@ -70,34 +65,40 @@ extern int isatty(int);
 extern FILE *fpopen(const char *cmd, const char *mode);
 
 const char * program_name = "mke2fs";
-const char * device_name = NULL;
+const char * device_name /* = NULL */;
 
 /* Command line options */
-int	cflag = 0;
-int	verbose = 0;
-int	quiet = 0;
-int	super_only = 0;
-int	force = 0;
-int	noaction = 0;
-char	*bad_blocks_filename = 0;
-__u32	fs_stride = 0;
-
-struct ext2_super_block param;
-char *creator_os = NULL;
-char *volume_label = NULL;
-char *mount_dir = NULL;
-
-static void usage(NOARGS), check_plausibility(NOARGS), check_mount(NOARGS);
-
-static void usage(NOARGS)
+int	cflag;
+int	verbose;
+int	quiet;
+int	super_only;
+int	force;
+int	noaction;
+int	journal_size;
+int	journal_flags;
+char	*bad_blocks_filename;
+__u32	fs_stride;
+
+struct ext2_super_block fs_param;
+char *creator_os;
+char *volume_label;
+char *mount_dir;
+char *journal_device;
+int sync_kludge;	/* Set using the MKE2FS_SYNC env. option */
+
+profile_t	profile;
+
+int sys_page_size = 4096;
+int linux_version_code = 0;
+
+static void usage(void)
 {
 	fprintf(stderr, _("Usage: %s [-c|-t|-l filename] [-b block-size] "
-	"[-f fragment-size]\n\t[-i bytes-per-inode] "
+	"[-f fragment-size]\n\t[-i bytes-per-inode] [-j] [-J journal-options]"
 	" [-N number-of-inodes]\n\t[-m reserved-blocks-percentage] "
 	"[-o creator-os] [-g blocks-per-group]\n\t[-L volume-label] "
 	"[-M last-mounted-directory] [-O feature[,...]]\n\t"
-	"[-r fs-revision] [-R raid_opts] [-s sparse-super-flag]\n\t"
-	"[-qvSV] device [blocks-count]\n"),
+	"[-r fs-revision] [-R options] [-qvSV] device [blocks-count]\n"),
 		program_name);
 	exit(1);
 }
@@ -123,144 +124,34 @@ static int int_log10(unsigned int arg)
 	return l;
 }
 
-static void proceed_question(NOARGS)
-{
-	char buf[256];
-	char *short_yes = _("yY");
-
-	fflush(stdout);
-	fflush(stderr);
-	printf(_("Proceed anyway? (y,n) "));
-	buf[0] = 0;
-	fgets(buf, sizeof(buf), stdin);
-	if (strchr(short_yes, buf[0]) == 0)
-		exit(1);
-}
-
-#ifndef SCSI_BLK_MAJOR
-#define SCSI_BLK_MAJOR(M)  ((M) == SCSI_DISK_MAJOR || (M) == SCSI_CDROM_MAJOR)
-#endif
-
-static void check_plausibility(NOARGS)
+static int parse_version_number(const char *s)
 {
-#ifdef HAVE_LINUX_MAJOR_H
-#ifndef MAJOR
-#define MAJOR(dev)	((dev)>>8)
-#define MINOR(dev)	((dev) & 0xff)
-#endif
+	int	major, minor, rev;
+	char	*endptr;
+	const char *cp = s;
 
-	int val;
-	struct stat s;
-	
-	val = stat(device_name, &s);
-	
-	if(val == -1) {
-		fprintf(stderr, _("Could not stat %s --- %s\n"),
-			device_name, error_message(errno));
-		if (errno == ENOENT)
-			fprintf(stderr, _("\nThe device apparently does "
-			       "not exist; did you specify it correctly?\n"));
-		exit(1);
-	}
-	if(!S_ISBLK(s.st_mode)) {
-		printf(_("%s is not a block special device.\n"), device_name);
-		proceed_question();
-		return;
-	} else if ((MAJOR(s.st_rdev) == HD_MAJOR &&
-		    MINOR(s.st_rdev)%64 == 0) ||
-		   (SCSI_BLK_MAJOR(MAJOR(s.st_rdev)) &&
-		       MINOR(s.st_rdev)%16 == 0)) {
-		printf(_("%s is entire device, not just one partition!\n"),
-		       device_name);
-		proceed_question();
-	}
-#endif
-}
-
-static void check_mount(NOARGS)
-{
-	errcode_t	retval;
-	int		mount_flags;
-
-	retval = ext2fs_check_if_mounted(device_name, &mount_flags);
-	if (retval) {
-		com_err("ext2fs_check_if_mount", retval,
-			_("while determining whether %s is mounted."),
-			device_name);
-		return;
-	}
-	if (!(mount_flags & EXT2_MF_MOUNTED))
-		return;
-
-	fprintf(stderr, _("%s is mounted; "), device_name);
-	if (force) {
-		fprintf(stderr, _("mke2fs forced anyway.  "
-			"Hope /etc/mtab is incorrect.\n"));
-	} else {
-		fprintf(stderr, _("will not make a filesystem here!\n"));
-		exit(1);
-	}
-}
-
-/*
- * This function sets the default parameters for a filesystem
- *
- * The type is specified by the user.  The size is the maximum size
- * (in megabytes) for which a set of parameters applies, with a size
- * of zero meaning that it is the default parameter for the type.
- * Note that order is important in the table below.
- */
-static char default_str[] = "default";
-struct mke2fs_defaults {
-	const char	*type;
-	int		size;
-	int		blocksize;
-	int		inode_ratio;
-} settings[] = {
-	{ default_str, 0, 4096, 8192 },
-	{ default_str, 512, 1024, 4096 },
-	{ default_str, 3, 1024, 8192 },
-	{ "news", 0, 4096, 4096 },
-	{ 0, 0, 0, 0},
-};
-
-static void set_fs_defaults(char *fs_type, struct ext2fs_sb *super,
-			    int blocksize, int *inode_ratio)
-{
-	int	megs;
-	int	ratio = 0;
-	struct mke2fs_defaults *p;
-
-	megs = (super->s_blocks_count * (EXT2_BLOCK_SIZE(super) / 1024) /
-		1024);
-	if (inode_ratio)
-		ratio = *inode_ratio;
-	if (!fs_type)
-		fs_type = default_str;
-	for (p = settings; p->type; p++) {
-		if ((strcmp(p->type, fs_type) != 0) &&
-		    (strcmp(p->type, default_str) != 0))
-			continue;
-		if ((p->size != 0) &&
-		    (megs > p->size))
-			continue;
-		if (ratio == 0)
-			*inode_ratio = p->inode_ratio;
-		if (blocksize == 0) {
-			super->s_log_frag_size = super->s_log_block_size =
-				int_log2(p->blocksize >> EXT2_MIN_BLOCK_LOG_SIZE);
-		}
-	}
-	if (blocksize == 0)
-		super->s_blocks_count /= EXT2_BLOCK_SIZE(super) / 1024;
+	if (!s)
+		return 0;
+	major = strtol(cp, &endptr, 10);
+	if (cp == endptr || *endptr != '.')
+		return 0;
+	cp = endptr + 1;
+	minor = strtol(cp, &endptr, 10);
+	if (cp == endptr || *endptr != '.')
+		return 0;
+	cp = endptr + 1;
+	rev = strtol(cp, &endptr, 10);
+	if (cp == endptr)
+		return 0;
+	return ((((major * 256) + minor) * 256) + rev);
 }
 
 /*
  * Helper function for read_bb_file and test_disk
  */
-static void invalid_block(ext2_filsys fs, blk_t blk)
+static void invalid_block(ext2_filsys fs EXT2FS_ATTR((unused)), blk_t blk)
 {
-	printf(_("Bad block %u out of range; ignored.\n"), blk);
+	fprintf(stderr, _("Bad block %u out of range; ignored.\n"), blk);
 	return;
 }
 
@@ -297,15 +188,15 @@ static void test_disk(ext2_filsys fs, badblocks_list *bb_list)
 	errcode_t	retval;
 	char		buf[1024];
 
-	sprintf(buf, "badblocks -b %d %s%s %d", fs->blocksize,
-		quiet ? "" : "-s ", fs->device_name,
-		fs->super->s_blocks_count);
+	sprintf(buf, "badblocks -b %d -X %s%s%s %d", fs->blocksize,
+		quiet ? "" : "-s ", (cflag > 1) ? "-w " : "",
+		fs->device_name, fs->super->s_blocks_count);
 	if (verbose)
 		printf(_("Running command: %s\n"), buf);
 	f = popen(buf, "r");
 	if (!f) {
 		com_err("popen", errno,
-			_("while trying run '%s'"), buf);
+			_("while trying to run '%s'"), buf);
 		exit(1);
 	}
 	retval = ext2fs_read_bb_FILE(fs, f, bb_list, invalid_block);
@@ -319,8 +210,9 @@ static void test_disk(ext2_filsys fs, badblocks_list *bb_list)
 
 static void handle_bad_blocks(ext2_filsys fs, badblocks_list bb_list)
 {
-	int			i, j;
-	int			must_be_good;
+	dgrp_t			i;
+	blk_t			j;
+	unsigned 		must_be_good;
 	blk_t			blk;
 	badblocks_iterate	bb_iter;
 	errcode_t		retval;
@@ -337,13 +229,13 @@ static void handle_bad_blocks(ext2_filsys fs, badblocks_list bb_list)
 	 */
 	must_be_good = fs->super->s_first_data_block + 1 + fs->desc_blocks;
 	for (i = fs->super->s_first_data_block; i <= must_be_good; i++) {
-		if (badblocks_list_test(bb_list, i)) {
+		if (ext2fs_badblocks_list_test(bb_list, i)) {
 			fprintf(stderr, _("Block %d in primary "
 				"superblock/group descriptor area bad.\n"), i);
-			fprintf(stderr, _("Blocks %d through %d must be good "
+			fprintf(stderr, _("Blocks %u through %d must be good "
 				"in order to build a filesystem.\n"),
 				fs->super->s_first_data_block, must_be_good);
-			fprintf(stderr, _("Aborting....\n"));
+			fputs(_("Aborting....\n"), stderr);
 			exit(1);
 		}
 	}
@@ -359,11 +251,11 @@ static void handle_bad_blocks(ext2_filsys fs, badblocks_list bb_list)
 	for (i = 1; i < fs->group_desc_count; i++) {
 		group_bad = 0;
 		for (j=0; j < fs->desc_blocks+1; j++) {
-			if (badblocks_list_test(bb_list, group_block +
-						j)) {
+			if (ext2fs_badblocks_list_test(bb_list,
+						       group_block + j)) {
 				if (!group_bad) 
 					fprintf(stderr,
-_("Warning: the backup superblock/group descriptors at block %d contain\n"
+_("Warning: the backup superblock/group descriptors at block %u contain\n"
 "	bad blocks.\n\n"),
 						group_block);
 				group_bad++;
@@ -378,71 +270,167 @@ _("Warning: the backup superblock/group descriptors at block %d contain\n"
 	/*
 	 * Mark all the bad blocks as used...
 	 */
-	retval = badblocks_list_iterate_begin(bb_list, &bb_iter);
+	retval = ext2fs_badblocks_list_iterate_begin(bb_list, &bb_iter);
 	if (retval) {
-		com_err("badblocks_list_iterate_begin", retval,
+		com_err("ext2fs_badblocks_list_iterate_begin", retval,
 			_("while marking bad blocks as used"));
 		exit(1);
 	}
-	while (badblocks_list_iterate(bb_iter, &blk)) 
+	while (ext2fs_badblocks_list_iterate(bb_iter, &blk)) 
 		ext2fs_mark_block_bitmap(fs->block_map, blk);
-	badblocks_list_iterate_end(bb_iter);
+	ext2fs_badblocks_list_iterate_end(bb_iter);
 }
 
-static void write_inode_tables(ext2_filsys fs)
-{
-	errcode_t	retval;
-	blk_t		blk;
-	int		i, j, num, count;
-	char		*buf;
-	char		format[20], backup[80];
-	int		sync_kludge = 0;
-	char		*mke2fs_sync;
+/*
+ * These functions implement a generalized progress meter.
+ */
+struct progress_struct {
+	char		format[20];
+	char		backup[80];
+	__u32		max;
+	int		skip_progress;
+};
 
-	mke2fs_sync = getenv("MKE2FS_SYNC");
-	if (mke2fs_sync)
-		sync_kludge = atoi(mke2fs_sync);
+static void progress_init(struct progress_struct *progress,
+			  const char *label,__u32 max)
+{
+	int	i;
 
-	buf = malloc(fs->blocksize * STRIDE_LENGTH);
-	if (!buf) {
-		com_err("malloc", ENOMEM,
-			_("while allocating zeroizing buffer"));
-		exit(1);
-	}
-	memset(buf, 0, fs->blocksize * STRIDE_LENGTH);
+	memset(progress, 0, sizeof(struct progress_struct));
+	if (quiet)
+		return;
 
 	/*
 	 * Figure out how many digits we need
 	 */
-	i = int_log10(fs->group_desc_count);
-	sprintf(format, "%%%dd/%%%dld", i, i);
-	memset(backup, '\b', sizeof(backup)-1);
-	backup[sizeof(backup)-1] = 0;
-	if ((2*i)+1 < sizeof(backup))
-		backup[(2*i)+1] = 0;
+	i = int_log10(max);
+	sprintf(progress->format, "%%%dd/%%%dld", i, i);
+	memset(progress->backup, '\b', sizeof(progress->backup)-1);
+	progress->backup[sizeof(progress->backup)-1] = 0;
+	if ((2*i)+1 < (int) sizeof(progress->backup))
+		progress->backup[(2*i)+1] = 0;
+	progress->max = max;
+
+	progress->skip_progress = 0;
+	if (getenv("MKE2FS_SKIP_PROGRESS"))
+		progress->skip_progress++;
+
+	fputs(label, stdout);
+	fflush(stdout);
+}
+
+static void progress_update(struct progress_struct *progress, __u32 val)
+{
+	if ((progress->format[0] == 0) || progress->skip_progress)
+		return;
+	printf(progress->format, val, progress->max);
+	fputs(progress->backup, stdout);
+}
+
+static void progress_close(struct progress_struct *progress)
+{
+	if (progress->format[0] == 0)
+		return;
+	fputs(_("done                            \n"), stdout);
+}
+
+
+/*
+ * Helper function which zeros out _num_ blocks starting at _blk_.  In
+ * case of an error, the details of the error is returned via _ret_blk_
+ * and _ret_count_ if they are non-NULL pointers.  Returns 0 on
+ * success, and an error code on an error.
+ *
+ * As a special case, if the first argument is NULL, then it will
+ * attempt to free the static zeroizing buffer.  (This is to keep
+ * programs that check for memory leaks happy.)
+ */
+static errcode_t zero_blocks(ext2_filsys fs, blk_t blk, int num,
+			     struct progress_struct *progress,
+			     blk_t *ret_blk, int *ret_count)
+{
+	int		j, count, next_update, next_update_incr;
+	static char	*buf;
+	errcode_t	retval;
+
+	/* If fs is null, clean up the static buffer and return */
+	if (!fs) {
+		if (buf) {
+			free(buf);
+			buf = 0;
+		}
+		return 0;
+	}
+	/* Allocate the zeroizing buffer if necessary */
+	if (!buf) {
+		buf = malloc(fs->blocksize * STRIDE_LENGTH);
+		if (!buf) {
+			com_err("malloc", ENOMEM,
+				_("while allocating zeroizing buffer"));
+			exit(1);
+		}
+		memset(buf, 0, fs->blocksize * STRIDE_LENGTH);
+	}
+	/* OK, do the write loop */
+	next_update = 0;
+	next_update_incr = num / 100;
+	if (next_update_incr < 1)
+		next_update_incr = 1;
+	for (j=0; j < num; j += STRIDE_LENGTH, blk += STRIDE_LENGTH) {
+		count = num - j;
+		if (count > STRIDE_LENGTH)
+			count = STRIDE_LENGTH;
+		retval = io_channel_write_blk(fs->io, blk, count, buf);
+		if (retval) {
+			if (ret_count)
+				*ret_count = count;
+			if (ret_blk)
+				*ret_blk = blk;
+			return retval;
+		}
+		if (progress && j > next_update) {
+			next_update += num / 100;
+			progress_update(progress, blk);
+		}
+	}
+	return 0;
+}	
+
+static void write_inode_tables(ext2_filsys fs)
+{
+	errcode_t	retval;
+	blk_t		blk;
+	dgrp_t		i;
+	int		num;
+	struct progress_struct progress;
+	int		lazy_flag = 0;
+
+	if (quiet)
+		memset(&progress, 0, sizeof(progress));
+	else
+		progress_init(&progress, _("Writing inode tables: "),
+			      fs->group_desc_count);
+
+	if (EXT2_HAS_COMPAT_FEATURE(fs->super, 
+				    EXT2_FEATURE_COMPAT_LAZY_BG))
+		lazy_flag = 1;
 
-	if (!quiet)
-		printf(_("Writing inode tables: "));
 	for (i = 0; i < fs->group_desc_count; i++) {
-		if (!quiet)
-			printf(format, i, fs->group_desc_count);
+		progress_update(&progress, i);
 		
 		blk = fs->group_desc[i].bg_inode_table;
 		num = fs->inode_blocks_per_group;
-		
-		for (j=0; j < num; j += STRIDE_LENGTH, blk += STRIDE_LENGTH) {
-			if (num-j > STRIDE_LENGTH)
-				count = STRIDE_LENGTH;
-			else
-				count = num - j;
-			retval = io_channel_write_blk(fs->io, blk, count, buf);
-			if (retval)
-				printf(_("Warning: could not write %d blocks "
-				       "in inode table starting at %d: %s\n"),
-				       count, blk, error_message(retval));
+
+		if (!(lazy_flag &&
+		      (fs->group_desc[i].bg_flags & EXT2_BG_INODE_UNINIT))) {
+			retval = zero_blocks(fs, blk, num, 0, &blk, &num);
+			if (retval) {
+				fprintf(stderr, _("\nCould not write %d "
+				"blocks in inode table starting at %u: %s\n"),
+					num, blk, error_message(retval));
+				exit(1);
+			}
 		}
-		if (!quiet) 
-			fputs(backup, stdout);
 		if (sync_kludge) {
 			if (sync_kludge == 1)
 				sync();
@@ -450,11 +438,41 @@ static void write_inode_tables(ext2_filsys fs)
 				sync();
 		}
 	}
-	free(buf);
-	if (!quiet)
-		fputs(_("done                            \n"), stdout);
+	zero_blocks(0, 0, 0, 0, 0, 0);
+	progress_close(&progress);
 }
 
+static void setup_lazy_bg(ext2_filsys fs)
+{
+	dgrp_t i;
+	int blks;
+	struct ext2_super_block *sb = fs->super;
+	struct ext2_group_desc *bg = fs->group_desc;
+
+	if (EXT2_HAS_COMPAT_FEATURE(fs->super, 
+				    EXT2_FEATURE_COMPAT_LAZY_BG)) {
+		for (i = 0; i < fs->group_desc_count; i++, bg++) {
+			if ((i == 0) ||
+			    (i == fs->group_desc_count-1))
+				continue;
+			if (bg->bg_free_inodes_count ==
+			    sb->s_inodes_per_group) {
+				bg->bg_free_inodes_count = 0;
+				bg->bg_flags |= EXT2_BG_INODE_UNINIT;
+				sb->s_free_inodes_count -= 
+					sb->s_inodes_per_group;
+			}
+			blks = ext2fs_super_and_bgd_loc(fs, i, 0, 0, 0, 0);
+			if (bg->bg_free_blocks_count == blks) {
+				bg->bg_free_blocks_count = 0;
+				bg->bg_flags |= EXT2_BG_BLOCK_UNINIT;
+				sb->s_free_blocks_count -= blks;
+			}
+		}
+	}
+}
+
+
 static void create_root_dir(ext2_filsys fs)
 {
 	errcode_t	retval;
@@ -475,7 +493,7 @@ static void create_root_dir(ext2_filsys fs)
 		inode.i_uid = getuid();
 		if (inode.i_uid)
 			inode.i_gid = getgid();
-		retval = ext2fs_write_inode(fs, EXT2_ROOT_INO, &inode);
+		retval = ext2fs_write_new_inode(fs, EXT2_ROOT_INO, &inode);
 		if (retval) {
 			com_err("ext2fs_write_inode", retval,
 				_("while setting root inode ownership"));
@@ -487,11 +505,12 @@ static void create_root_dir(ext2_filsys fs)
 static void create_lost_and_found(ext2_filsys fs)
 {
 	errcode_t		retval;
-	ino_t			ino;
+	ext2_ino_t		ino;
 	const char		*name = "lost+found";
 	int			i;
 	int			lpf_size = 0;
 
+	fs->umask = 077;
 	retval = ext2fs_mkdir(fs, EXT2_ROOT_INO, 0, name);
 	if (retval) {
 		com_err("ext2fs_mkdir", retval,
@@ -515,7 +534,7 @@ static void create_lost_and_found(ext2_filsys fs)
 				_("while expanding /lost+found"));
 			exit(1);
 		}
-	}		
+	}
 }
 
 static void create_bad_block_inode(ext2_filsys fs, badblocks_list bb_list)
@@ -536,8 +555,8 @@ static void create_bad_block_inode(ext2_filsys fs, badblocks_list bb_list)
 
 static void reserve_inodes(ext2_filsys fs)
 {
-	ino_t	i;
-	int	group;
+	ext2_ino_t	i;
+	int		group;
 
 	for (i = EXT2_ROOT_INO + 1; i < EXT2_FIRST_INODE(fs->super); i++) {
 		ext2fs_mark_inode_bitmap(fs->inode_map, i);
@@ -548,43 +567,110 @@ static void reserve_inodes(ext2_filsys fs)
 	ext2fs_mark_ib_dirty(fs);
 }
 
-static void zap_sector(ext2_filsys fs, int sect)
+#define BSD_DISKMAGIC   (0x82564557UL)  /* The disk magic number */
+#define BSD_MAGICDISK   (0x57455682UL)  /* The disk magic number reversed */
+#define BSD_LABEL_OFFSET        64
+
+static void zap_sector(ext2_filsys fs, int sect, int nsect)
 {
-	char buf[512];
+	char *buf;
 	int retval;
+	unsigned int *magic;
 
-	memset(buf, 0, 512);
-	
+	buf = malloc(512*nsect);
+	if (!buf) {
+		printf(_("Out of memory erasing sectors %d-%d\n"),
+		       sect, sect + nsect - 1);
+		exit(1);
+	}
+
+	if (sect == 0) {
+		/* Check for a BSD disklabel, and don't erase it if so */
+		retval = io_channel_read_blk(fs->io, 0, -512, buf);
+		if (retval)
+			fprintf(stderr,
+				_("Warning: could not read block 0: %s\n"),
+				error_message(retval));
+		else {
+			magic = (unsigned int *) (buf + BSD_LABEL_OFFSET);
+			if ((*magic == BSD_DISKMAGIC) ||
+			    (*magic == BSD_MAGICDISK))
+				return;
+		}
+	}
+
+	memset(buf, 0, 512*nsect);
 	io_channel_set_blksize(fs->io, 512);
-	retval = io_channel_write_blk(fs->io, sect, -512, buf);
+	retval = io_channel_write_blk(fs->io, sect, -512*nsect, buf);
 	io_channel_set_blksize(fs->io, fs->blocksize);
+	free(buf);
 	if (retval)
-		printf(_("Warning: could not erase sector %d: %s\n"), sect,
-		       error_message(retval));
+		fprintf(stderr, _("Warning: could not erase sector %d: %s\n"),
+			sect, error_message(retval));
+}
+
+static void create_journal_dev(ext2_filsys fs)
+{
+	struct progress_struct progress;
+	errcode_t		retval;
+	char			*buf;
+	blk_t			blk;
+	int			count;
+
+	retval = ext2fs_create_journal_superblock(fs,
+				  fs->super->s_blocks_count, 0, &buf);
+	if (retval) {
+		com_err("create_journal_dev", retval,
+			_("while initializing journal superblock"));
+		exit(1);
+	}
+	if (quiet)
+		memset(&progress, 0, sizeof(progress));
+	else
+		progress_init(&progress, _("Zeroing journal device: "),
+			      fs->super->s_blocks_count);
+
+	retval = zero_blocks(fs, 0, fs->super->s_blocks_count,
+			     &progress, &blk, &count);
+	if (retval) {
+		com_err("create_journal_dev", retval,
+			_("while zeroing journal device (block %u, count %d)"),
+			blk, count);
+		exit(1);
+	}
+	zero_blocks(0, 0, 0, 0, 0, 0);
+
+	retval = io_channel_write_blk(fs->io,
+				      fs->super->s_first_data_block+1,
+				      1, buf);
+	if (retval) {
+		com_err("create_journal_dev", retval,
+			_("while writing journal superblock"));
+		exit(1);
+	}
+	progress_close(&progress);
 }
-	
 
 static void show_stats(ext2_filsys fs)
 {
-	struct ext2fs_sb 	*s = (struct ext2fs_sb *) fs->super;
+	struct ext2_super_block *s = fs->super;
 	char 			buf[80];
+        char                    *os;
 	blk_t			group_block;
-	int			i, need, col_left;
+	dgrp_t			i;
+	int			need, col_left;
 	
-	if (param.s_blocks_count != s->s_blocks_count)
-		printf(_("warning: %d blocks unused.\n\n"),
-		       param.s_blocks_count - s->s_blocks_count);
+	if (fs_param.s_blocks_count != s->s_blocks_count)
+		fprintf(stderr, _("warning: %u blocks unused.\n\n"),
+		       fs_param.s_blocks_count - s->s_blocks_count);
 
 	memset(buf, 0, sizeof(buf));
 	strncpy(buf, s->s_volume_name, sizeof(s->s_volume_name));
 	printf(_("Filesystem label=%s\n"), buf);
-	printf(_("OS type: "));
-	switch (fs->super->s_creator_os) {
-	    case EXT2_OS_LINUX: printf ("Linux"); break;
-	    case EXT2_OS_HURD:  printf ("GNU/Hurd");   break;
-	    case EXT2_OS_MASIX: printf ("Masix"); break;
-	    default:		printf (_("(unknown os)"));
-        }
+	fputs(_("OS type: "), stdout);
+        os = e2p_os2string(fs->super->s_creator_os);
+	fputs(os, stdout);
+	free(os);
 	printf("\n");
 	printf(_("Block size=%u (log=%u)\n"), fs->blocksize,
 		s->s_log_block_size);
@@ -596,10 +682,15 @@ static void show_stats(ext2_filsys fs)
 		s->s_r_blocks_count,
 	       100.0 * s->s_r_blocks_count / s->s_blocks_count);
 	printf(_("First data block=%u\n"), s->s_first_data_block);
+	if (s->s_reserved_gdt_blocks)
+		printf(_("Maximum filesystem blocks=%lu\n"),
+		       (s->s_reserved_gdt_blocks + fs->desc_blocks) *
+		       (fs->blocksize / sizeof(struct ext2_group_desc)) *
+		       s->s_blocks_per_group);
 	if (fs->group_desc_count > 1)
-		printf(_("%lu block groups\n"), fs->group_desc_count);
+		printf(_("%u block groups\n"), fs->group_desc_count);
 	else
-		printf(_("%lu block group\n"), fs->group_desc_count);
+		printf(_("%u block group\n"), fs->group_desc_count);
 	printf(_("%u blocks per group, %u fragments per group\n"),
 	       s->s_blocks_per_group, s->s_frags_per_group);
 	printf(_("%u inodes per group\n"), s->s_inodes_per_group);
@@ -608,7 +699,7 @@ static void show_stats(ext2_filsys fs)
 		printf("\n");
 		return;
 	}
-	
+
 	printf(_("Superblock backups stored on blocks: "));
 	group_block = s->s_first_data_block;
 	col_left = 0;
@@ -629,22 +720,6 @@ static void show_stats(ext2_filsys fs)
 	printf("\n\n");
 }
 
-#ifndef HAVE_STRCASECMP
-static int strcasecmp (char *s1, char *s2)
-{
-	while (*s1 && *s2) {
-		int ch1 = *s1++, ch2 = *s2++;
-		if (isupper (ch1))
-			ch1 = tolower (ch1);
-		if (isupper (ch2))
-			ch2 = tolower (ch2);
-		if (ch1 != ch2)
-			return ch1 - ch2;
-	}
-	return *s1 ? 1 : *s2 ? -1 : 0;
-}
-#endif
-
 /*
  * Set the S_CREATOR_OS field.  Return true if OS is known,
  * otherwise, 0.
@@ -659,6 +734,10 @@ static int set_os(struct ext2_super_block *sb, char *os)
 		sb->s_creator_os = EXT2_OS_HURD;
 	else if (strcasecmp(os, "masix") == 0)
 		sb->s_creator_os = EXT2_OS_MASIX;
+	else if (strcasecmp(os, "freebsd") == 0)
+		sb->s_creator_os = EXT2_OS_FREEBSD;
+	else if (strcasecmp(os, "lites") == 0)
+		sb->s_creator_os = EXT2_OS_LITES;
 	else
 		return 0;
 	return 1;
@@ -666,17 +745,18 @@ static int set_os(struct ext2_super_block *sb, char *os)
 
 #define PATH_SET "PATH=/sbin"
 
-static void parse_raid_opts(const char *opts)
+static void parse_extended_opts(struct ext2_super_block *param, 
+				const char *opts)
 {
 	char	*buf, *token, *next, *p, *arg;
 	int	len;
-	int	raid_usage = 0;
+	int	r_usage = 0;
 
 	len = strlen(opts);
 	buf = malloc(len+1);
 	if (!buf) {
-		fprintf(stderr, _("Couldn't allocate memory to parse "
-			"raid options!\n"));
+		fprintf(stderr,
+			_("Couldn't allocate memory to parse options!\n"));
 		exit(1);
 	}
 	strcpy(buf, opts);
@@ -686,7 +766,7 @@ static void parse_raid_opts(const char *opts)
 		if (p) {
 			*p = 0;
 			next = p+1;
-		} 
+		}
 		arg = strchr(token, '=');
 		if (arg) {
 			*arg = 0;
@@ -694,67 +774,141 @@ static void parse_raid_opts(const char *opts)
 		}
 		if (strcmp(token, "stride") == 0) {
 			if (!arg) {
-				raid_usage++;
+				r_usage++;
 				continue;
 			}
 			fs_stride = strtoul(arg, &p, 0);
 			if (*p || (fs_stride == 0)) {
 				fprintf(stderr,
-					_("Invalid stride parameter.\n"));
-				raid_usage++;
+					_("Invalid stride parameter: %s\n"),
+					arg);
+				r_usage++;
 				continue;
 			}
+		} else if (!strcmp(token, "resize")) {
+			unsigned long resize, bpg, rsv_groups;
+			unsigned long group_desc_count, desc_blocks;
+			unsigned int gdpb, blocksize;
+			int rsv_gdb;
+
+			if (!arg) {
+				r_usage++;
+				continue;
+			}
+
+			resize = parse_num_blocks(arg, 
+						  param->s_log_block_size);
+
+			if (resize == 0) {
+				fprintf(stderr, 
+					_("Invalid resize parameter: %s\n"),
+					arg);
+				r_usage++;
+				continue;
+			}
+			if (resize <= param->s_blocks_count) {
+				fprintf(stderr, 
+					_("The resize maximum must be greater "
+					  "than the filesystem size.\n"));
+				r_usage++;
+				continue;
+			}
+
+			blocksize = EXT2_BLOCK_SIZE(param);
+			bpg = param->s_blocks_per_group;
+			if (!bpg)
+				bpg = blocksize * 8;
+			gdpb = blocksize / sizeof(struct ext2_group_desc);
+			group_desc_count = (param->s_blocks_count +
+					    bpg - 1) / bpg;
+			desc_blocks = (group_desc_count +
+				       gdpb - 1) / gdpb;
+			rsv_groups = (resize + bpg - 1) / bpg;
+			rsv_gdb = (rsv_groups + gdpb - 1) / gdpb - 
+				desc_blocks;
+			if (rsv_gdb > (int) EXT2_ADDR_PER_BLOCK(param))
+				rsv_gdb = EXT2_ADDR_PER_BLOCK(param);
+
+			if (rsv_gdb > 0) {
+				param->s_feature_compat |=
+					EXT2_FEATURE_COMPAT_RESIZE_INODE;
+
+				param->s_reserved_gdt_blocks = rsv_gdb;
+			}
 		} else
-			raid_usage++;
+			r_usage++;
 	}
-	if (raid_usage) {
-		fprintf(stderr, _("\nBad raid options specified.\n\n"
-			"Raid options are separated by commas, "
+	if (r_usage) {
+		fprintf(stderr, _("\nBad options specified.\n\n"
+			"Extended options are separated by commas, "
 			"and may take an argument which\n"
 			"\tis set off by an equals ('=') sign.\n\n"
-			"Valid raid options are:\n"
-			"\tstride=<stride length in blocks>\n\n"));
+			"Valid extended options are:\n"
+			"\tstride=<stride length in blocks>\n"
+			"\tresize=<resize maximum size in blocks>\n\n"));
 		exit(1);
 	}
 }	
 
 static __u32 ok_features[3] = {
-	0,					/* Compat */
-	EXT2_FEATURE_INCOMPAT_FILETYPE,		/* Incompat */
+	EXT3_FEATURE_COMPAT_HAS_JOURNAL |
+		EXT2_FEATURE_COMPAT_RESIZE_INODE |
+		EXT2_FEATURE_COMPAT_DIR_INDEX |
+		EXT2_FEATURE_COMPAT_LAZY_BG,	/* Compat */
+	EXT2_FEATURE_INCOMPAT_FILETYPE|		/* Incompat */
+		EXT3_FEATURE_INCOMPAT_JOURNAL_DEV|
+		EXT2_FEATURE_INCOMPAT_META_BG,
 	EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER	/* R/O compat */
 };
 
 
+static void syntax_err_report(const char *filename, long err, int line_num)
+{
+	fprintf(stderr, 
+		_("Syntax error in mke2fs config file (%s, line #%d)\n\t%s\n"),
+		filename, line_num, error_message(err));
+	exit(1);
+}
+
+static const char *config_fn[] = { ROOT_SYSCONFDIR "/mke2fs.conf", 0 };
+
+static void edit_feature(const char *str, __u32 *compat_array) 
+{
+	if (!str)
+		return;
+
+	if (e2p_edit_feature(str, compat_array, ok_features)) {
+		fprintf(stderr, _("Invalid filesystem option set: %s\n"), 
+			str);
+		exit(1);
+	}
+}
+
 static void PRS(int argc, char *argv[])
 {
-	int		c;
+	int		b, c;
 	int		size;
-	char *		tmp;
-	blk_t		group_blk_max = 8192;
+	char 		*tmp, *tmp2;
 	int		blocksize = 0;
 	int		inode_ratio = 0;
-	int		reserved_ratio = 5;
-	ino_t		num_inodes = 0;
+	int		inode_size = 0;
+	double		reserved_ratio = 5.0;
+	int		sector_size = 0;
+	int		show_version_only = 0;
+	ext2_ino_t	num_inodes = 0;
 	errcode_t	retval;
-	int		sparse_option = 0;
 	char *		oldpath = getenv("PATH");
-	struct ext2fs_sb *param_ext2 = (struct ext2fs_sb *) &param;
-	char *		raid_opts = 0;
-	char *		fs_type = 0;
-	const char *	feature_set = "filetype,sparse_super";
+	char *		extended_opts = 0;
+	const char *	fs_type = 0;
 	blk_t		dev_size;
-#ifdef linux
+#ifdef __linux__
 	struct 		utsname ut;
-
-	if (uname(&ut)) {
-		perror("uname");
-		exit(1);
-	}
-	if ((ut.release[0] == '1') ||
-	    (ut.release[0] == '2' && ut.release[1] == '.' &&
-	     ut.release[2] < '2' && ut.release[3] == '.'))
-		feature_set = NULL;
 #endif
+	long		sysval;
+	int		s_opt = -1, r_opt = -1;
+	char		*fs_features = 0;
+	int		use_bsize;
+
 	/* Update our PATH to include /sbin  */
 	if (oldpath) {
 		char *newpath;
@@ -767,56 +921,98 @@ static void PRS(int argc, char *argv[])
 	} else
 		putenv (PATH_SET);
 
+	tmp = getenv("MKE2FS_SYNC");
+	if (tmp)
+		sync_kludge = atoi(tmp);
+
+	/* Determine the system page size if possible */
+#ifdef HAVE_SYSCONF
+#if (!defined(_SC_PAGESIZE) && defined(_SC_PAGE_SIZE))
+#define _SC_PAGESIZE _SC_PAGE_SIZE
+#endif
+#ifdef _SC_PAGESIZE
+	sysval = sysconf(_SC_PAGESIZE);
+	if (sysval > 0)
+		sys_page_size = sysval;
+#endif /* _SC_PAGESIZE */
+#endif /* HAVE_SYSCONF */
+
+	if ((tmp = getenv("MKE2FS_CONFIG")) != NULL)
+		config_fn[0] = tmp;
+	profile_set_syntax_err_cb(syntax_err_report);
+	profile_init(config_fn, &profile);
+	
 	setbuf(stdout, NULL);
 	setbuf(stderr, NULL);
 	initialize_ext2_error_table();
-	memset(&param, 0, sizeof(struct ext2_super_block));
-	param.s_rev_level = 1;  /* Create revision 1 filesystems now */
-	
-	fprintf (stderr, _("mke2fs %s, %s for EXT2 FS %s, %s\n"),
-		 E2FSPROGS_VERSION, E2FSPROGS_DATE,
-		 EXT2FS_VERSION, EXT2FS_DATE);
-	if (argc && *argv)
-		program_name = *argv;
+	memset(&fs_param, 0, sizeof(struct ext2_super_block));
+	fs_param.s_rev_level = 1;  /* Create revision 1 filesystems now */
+
+#ifdef __linux__
+	if (uname(&ut)) {
+		perror("uname");
+		exit(1);
+	}
+	linux_version_code = parse_version_number(ut.release);
+	if (linux_version_code && linux_version_code < (2*65536 + 2*256))
+		fs_param.s_rev_level = 0;
+#endif
+
+	if (argc && *argv) {
+		program_name = get_progname(*argv);
+
+		/* If called as mkfs.ext3, create a journal inode */
+		if (!strcmp(program_name, "mkfs.ext3"))
+			journal_size = -1;
+	}
+
 	while ((c = getopt (argc, argv,
-		    "b:cf:g:i:l:m:no:qr:R:s:tvI:ST:FL:M:N:O:V")) != EOF)
+		    "b:cf:g:i:jl:m:no:qr:s:tvE:FI:J:L:M:N:O:R:ST:V")) != EOF) {
 		switch (c) {
 		case 'b':
-			blocksize = strtoul(optarg, &tmp, 0);
-			if (blocksize < 1024 || blocksize > 4096 || *tmp) {
+			blocksize = strtol(optarg, &tmp, 0);
+			b = (blocksize > 0) ? blocksize : -blocksize;
+			if (b < EXT2_MIN_BLOCK_SIZE ||
+			    b > EXT2_MAX_BLOCK_SIZE || *tmp) {
 				com_err(program_name, 0,
-					_("bad block size - %s"), optarg);
+					_("invalid block size - %s"), optarg);
 				exit(1);
 			}
-			param.s_log_block_size =
-				int_log2(blocksize >> EXT2_MIN_BLOCK_LOG_SIZE);
-			group_blk_max = blocksize * 8;
+			if (blocksize > 4096)
+				fprintf(stderr, _("Warning: blocksize %d not "
+						  "usable on most systems.\n"),
+					blocksize);
+			if (blocksize > 0) 
+				fs_param.s_log_block_size =
+					int_log2(blocksize >>
+						 EXT2_MIN_BLOCK_LOG_SIZE);
 			break;
-		case 'c':
-		case 't':	/* Check for bad blocks */
-			cflag = 1;
+		case 'c':	/* Check for bad blocks */
+		case 't':	/* deprecated */
+			cflag++;
 			break;
 		case 'f':
 			size = strtoul(optarg, &tmp, 0);
-			if (size < 1024 || size > 4096 || *tmp) {
+			if (size < EXT2_MIN_BLOCK_SIZE ||
+			    size > EXT2_MAX_BLOCK_SIZE || *tmp) {
 				com_err(program_name, 0,
-					_("bad fragment size - %s"),
+					_("invalid fragment size - %s"),
 					optarg);
 				exit(1);
 			}
-			param.s_log_frag_size =
+			fs_param.s_log_frag_size =
 				int_log2(size >> EXT2_MIN_BLOCK_LOG_SIZE);
-			printf(_("Warning: fragments not supported.  "
+			fprintf(stderr, _("Warning: fragments not supported.  "
 			       "Ignoring -f option\n"));
 			break;
 		case 'g':
-			param.s_blocks_per_group = strtoul(optarg, &tmp, 0);
+			fs_param.s_blocks_per_group = strtoul(optarg, &tmp, 0);
 			if (*tmp) {
 				com_err(program_name, 0,
 					_("Illegal number for blocks per group"));
 				exit(1);
 			}
-			if ((param.s_blocks_per_group % 8) != 0) {
+			if ((fs_param.s_blocks_per_group % 8) != 0) {
 				com_err(program_name, 0,
 				_("blocks per group must be multiple of 8"));
 				exit(1);
@@ -824,13 +1020,23 @@ static void PRS(int argc, char *argv[])
 			break;
 		case 'i':
 			inode_ratio = strtoul(optarg, &tmp, 0);
-			if (inode_ratio < 1024 || inode_ratio > 256 * 1024 ||
+			if (inode_ratio < EXT2_MIN_BLOCK_SIZE ||
+			    inode_ratio > EXT2_MAX_BLOCK_SIZE * 1024 ||
 			    *tmp) {
 				com_err(program_name, 0,
-					_("bad inode ratio - %s"), optarg);
+					_("invalid inode ratio %s (min %d/max %d)"),
+					optarg, EXT2_MIN_BLOCK_SIZE,
+					EXT2_MAX_BLOCK_SIZE);
 				exit(1);
 			}
 			break;
+		case 'J':
+			parse_journal_opts(optarg);
+			break;
+		case 'j':
+			if (!journal_size)
+				journal_size = -1;
+			break;
 		case 'l':
 			bad_blocks_filename = malloc(strlen(optarg)+1);
 			if (!bad_blocks_filename) {
@@ -841,10 +1047,10 @@ static void PRS(int argc, char *argv[])
 			strcpy(bad_blocks_filename, optarg);
 			break;
 		case 'm':
-			reserved_ratio = strtoul(optarg, &tmp, 0);
+			reserved_ratio = strtod(optarg, &tmp);
 			if (reserved_ratio > 50 || *tmp) {
 				com_err(program_name, 0,
-					_("bad reserved blocks percent - %s"),
+					_("invalid reserved blocks percent - %s"),
 					optarg);
 				exit(1);
 			}
@@ -855,26 +1061,34 @@ static void PRS(int argc, char *argv[])
 		case 'o':
 			creator_os = optarg;
 			break;
+		case 'q':
+			quiet = 1;
+			break;
 		case 'r':
-			param.s_rev_level = atoi(optarg);
+			r_opt = strtoul(optarg, &tmp, 0);
+			if (*tmp) {
+				com_err(program_name, 0,
+					_("bad revision level - %s"), optarg);
+				exit(1);
+			}
+			fs_param.s_rev_level = r_opt;
 			break;
-		case 's':
-			sparse_option = atoi(optarg);
+		case 's':	/* deprecated */
+			s_opt = atoi(optarg);
 			break;
 #ifdef EXT2_DYNAMIC_REV
 		case 'I':
-			param.s_inode_size = atoi(optarg);
+			inode_size = strtoul(optarg, &tmp, 0);
+			if (*tmp) {
+				com_err(program_name, 0,
+					_("invalid inode size - %s"), optarg);
+				exit(1);
+			}
 			break;
 #endif
-		case 'N':
-			num_inodes = atoi(optarg);
-			break;
 		case 'v':
 			verbose = 1;
 			break;
-		case 'q':
-			quiet = 1;
-			break;
 		case 'F':
 			force = 1;
 			break;
@@ -884,11 +1098,20 @@ static void PRS(int argc, char *argv[])
 		case 'M':
 			mount_dir = optarg;
 			break;
+		case 'N':
+			num_inodes = strtoul(optarg, &tmp, 0);
+			if (*tmp) {
+				com_err(program_name, 0,
+					_("bad num inodes - %s"), optarg);
+					exit(1);
+			}
+			break;
 		case 'O':
-			feature_set = optarg;
+			fs_features = optarg;
 			break;
+		case 'E':
 		case 'R':
-			raid_opts = optarg;
+			extended_opts = optarg;
 			break;
 		case 'S':
 			super_only = 1;
@@ -898,51 +1121,114 @@ static void PRS(int argc, char *argv[])
 			break;
 		case 'V':
 			/* Print version number and exit */
-			fprintf(stderr, _("\tUsing %s\n"),
-				error_message(EXT2_ET_BASE));
-			exit(0);
+			show_version_only++;
+			break;
 		default:
 			usage();
 		}
-	if (optind == argc)
+	}
+	if ((optind == argc) && !show_version_only)
 		usage();
-	device_name = argv[optind];
-	optind++;
-	if (optind < argc) {
-		unsigned long tmp2  = strtoul(argv[optind++], &tmp, 0);
+	device_name = argv[optind++];
+
+	if (!quiet || show_version_only)
+		fprintf (stderr, "mke2fs %s (%s)\n", E2FSPROGS_VERSION, 
+			 E2FSPROGS_DATE);
+
+	if (show_version_only) {
+		fprintf(stderr, _("\tUsing %s\n"), 
+			error_message(EXT2_ET_BASE));
+		exit(0);
+	}
 
-		if ((*tmp) || (tmp2 > 0xfffffffful)) {
-			com_err(program_name, 0, _("bad blocks count - %s"),
+	/*
+	 * If there's no blocksize specified and there is a journal
+	 * device, use it to figure out the blocksize
+	 */
+	if (blocksize <= 0 && journal_device) {
+		ext2_filsys	jfs;
+		io_manager	io_ptr;
+
+#ifdef CONFIG_TESTIO_DEBUG
+		io_ptr = test_io_manager;
+		test_io_backing_manager = unix_io_manager;
+#else
+		io_ptr = unix_io_manager;
+#endif
+		retval = ext2fs_open(journal_device,
+				     EXT2_FLAG_JOURNAL_DEV_OK, 0,
+				     0, io_ptr, &jfs);
+		if (retval) {
+			com_err(program_name, retval,
+				_("while trying to open journal device %s\n"),
+				journal_device);
+			exit(1);
+		}
+		if ((blocksize < 0) && (jfs->blocksize < (unsigned) (-blocksize))) {
+			com_err(program_name, 0,
+				_("Journal dev blocksize (%d) smaller than "
+				  "minimum blocksize %d\n"), jfs->blocksize,
+				-blocksize);
+			exit(1);
+		}
+		blocksize = jfs->blocksize;
+		fs_param.s_log_block_size =
+			int_log2(blocksize >> EXT2_MIN_BLOCK_LOG_SIZE);
+		ext2fs_close(jfs);
+	}
+
+	if (blocksize > sys_page_size) {
+		if (!force) {
+			com_err(program_name, 0,
+				_("%d-byte blocks too big for system (max %d)"),
+				blocksize, sys_page_size);
+			proceed_question();
+		}
+		fprintf(stderr, _("Warning: %d-byte blocks too big for system "
+				  "(max %d), forced to continue\n"),
+			blocksize, sys_page_size);
+	}
+	if (optind < argc) {
+		fs_param.s_blocks_count = parse_num_blocks(argv[optind++], 
+				fs_param.s_log_block_size);
+		if (!fs_param.s_blocks_count) {
+			com_err(program_name, 0, _("invalid blocks count - %s"),
 				argv[optind - 1]);
 			exit(1);
 		}
-		param.s_blocks_count = tmp2;
 	}
 	if (optind < argc)
 		usage();
 
-	if (raid_opts)
-		parse_raid_opts(raid_opts);
-
 	if (!force)
-		check_plausibility();
-	check_mount();
+		check_plausibility(device_name);
+	check_mount(device_name, force, _("filesystem"));
 
-	param.s_log_frag_size = param.s_log_block_size;
+	fs_param.s_log_frag_size = fs_param.s_log_block_size;
 
-	if (noaction && param.s_blocks_count) {
-		dev_size = param.s_blocks_count;
+	if (noaction && fs_param.s_blocks_count) {
+		dev_size = fs_param.s_blocks_count;
 		retval = 0;
-	} else
+	} else {
+	retry:
 		retval = ext2fs_get_device_size(device_name,
-						EXT2_BLOCK_SIZE(&param),
+						EXT2_BLOCK_SIZE(&fs_param),
 						&dev_size);
+		if ((retval == EFBIG) &&
+		    (blocksize == 0) && 
+		    (fs_param.s_log_block_size == 0)) {
+			fs_param.s_log_block_size = 2;
+			blocksize = 4096;
+			goto retry;
+		}
+	}
+			
 	if (retval && (retval != EXT2_ET_UNIMPLEMENTED)) {
 		com_err(program_name, retval,
 			_("while trying to determine filesystem size"));
 		exit(1);
 	}
-	if (!param.s_blocks_count) {
+	if (!fs_param.s_blocks_count) {
 		if (retval == EXT2_ET_UNIMPLEMENTED) {
 			com_err(program_name, 0,
 				_("Couldn't determine device size; you "
@@ -962,73 +1248,232 @@ static void PRS(int argc, char *argv[])
 				  ));
 				exit(1);
 			}
-			param.s_blocks_count = dev_size;
+			fs_param.s_blocks_count = dev_size;
+			if (sys_page_size > EXT2_BLOCK_SIZE(&fs_param))
+				fs_param.s_blocks_count &= ~((sys_page_size /
+					   EXT2_BLOCK_SIZE(&fs_param))-1);
 		}
 		
-	} else if (!force && (param.s_blocks_count > dev_size)) {
+	} else if (!force && (fs_param.s_blocks_count > dev_size)) {
 		com_err(program_name, 0,
-			_("Filesystem larger than apparent filesystem size."));
+			_("Filesystem larger than apparent device size."));
 		proceed_question();
 	}
 
-	set_fs_defaults(fs_type, param_ext2, blocksize, &inode_ratio);
+	if (!fs_type) {
+		int megs = fs_param.s_blocks_count * 
+			(EXT2_BLOCK_SIZE(&fs_param) / 1024) / 1024;
+
+		if (megs <= 3)
+			fs_type = "floppy";
+		else if (megs <= 512)
+			fs_type = "small";
+		else
+			fs_type = "default";
+	}
+
+	/* Figure out what features should be enabled */
+
+	if (r_opt == EXT2_GOOD_OLD_REV && fs_features) {
+		fprintf(stderr, _("Filesystem features not supported "
+				  "with revision 0 filesystems\n"));
+		exit(1);
+	}
+
+	profile_get_string(profile, "defaults", "base_features", 0,
+			   "filetype,sparse_super", &tmp);
+	profile_get_string(profile, "fs_types", fs_type, "base_features",
+			   tmp, &tmp2);
+	edit_feature(tmp2, &fs_param.s_feature_compat);
+	free(tmp);
+	free(tmp2);
+
+	profile_get_string(profile, "defaults", "default_features", 0,
+			   "", &tmp);
+	profile_get_string(profile, "fs_types", fs_type, 
+			   "default_features", tmp, &tmp2);
+	edit_feature(fs_features ? fs_features : tmp2, 
+		     &fs_param.s_feature_compat);
+	free(tmp);
+	free(tmp2);
+
+	if (s_opt > 0)
+		fs_param.s_feature_ro_compat |=
+			EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER;
+	else if (s_opt == 0)
+		fs_param.s_feature_ro_compat &=
+			~EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER;
+
+	if (journal_size != 0)
+		fs_param.s_feature_compat |= 
+			EXT3_FEATURE_COMPAT_HAS_JOURNAL;
+
+	if (fs_param.s_feature_incompat & 
+	    EXT3_FEATURE_INCOMPAT_JOURNAL_DEV) {
+		if (!fs_type)
+			fs_type = "journal";
+		reserved_ratio = 0;
+		fs_param.s_feature_incompat = EXT3_FEATURE_INCOMPAT_JOURNAL_DEV;
+		fs_param.s_feature_compat = 0;
+		fs_param.s_feature_ro_compat = 0;
+ 	}
+	
+	if (fs_param.s_rev_level == EXT2_GOOD_OLD_REV) {
+		fs_param.s_feature_incompat = 0;
+		fs_param.s_feature_compat = 0;
+		fs_param.s_feature_ro_compat = 0;
+	}
+
+	/* Set first meta blockgroup via an environment variable */
+	/* (this is mostly for debugging purposes) */
+	if ((fs_param.s_feature_incompat & EXT2_FEATURE_INCOMPAT_META_BG) &&
+	    ((tmp = getenv("MKE2FS_FIRST_META_BG"))))
+		fs_param.s_first_meta_bg = atoi(tmp);
+
+	/* Get the hardware sector size, if available */
+	retval = ext2fs_get_device_sectsize(device_name, &sector_size);
+	if (retval) {
+		com_err(program_name, retval,
+			_("while trying to determine hardware sector size"));
+		exit(1);
+	}
+
+	if ((tmp = getenv("MKE2FS_DEVICE_SECTSIZE")) != NULL)
+		sector_size = atoi(tmp);
+	
+	if (blocksize <= 0) {
+		profile_get_integer(profile, "defaults", "blocksize", 0,
+				    1024, &use_bsize);
+		profile_get_integer(profile, "fs_types", fs_type, 
+				    "blocksize", use_bsize, &use_bsize);
+
+		if (use_bsize == -1) {
+			use_bsize = sys_page_size;
+			if ((linux_version_code < (2*65536 + 6*256)) &&
+			    (use_bsize > 4096))
+				use_bsize = 4096;
+		}
+		if (sector_size && use_bsize < sector_size)
+			use_bsize = sector_size;
+		if ((blocksize < 0) && (use_bsize < (-blocksize)))
+			use_bsize = -blocksize;
+		blocksize = use_bsize;
+		fs_param.s_blocks_count /= blocksize / 1024;
+	}
+
+	if (inode_ratio == 0) {
+		profile_get_integer(profile, "defaults", "inode_ratio", 0,
+				    8192, &inode_ratio);
+		profile_get_integer(profile, "fs_types", fs_type, 
+				    "inode_ratio", inode_ratio, 
+				    &inode_ratio);
 
-	if (param.s_blocks_per_group) {
-		if (param.s_blocks_per_group < 256 ||
-		    param.s_blocks_per_group > group_blk_max || *tmp) {
+		if (inode_ratio < blocksize)
+			inode_ratio = blocksize;
+	}
+
+	fs_param.s_log_frag_size = fs_param.s_log_block_size =
+		int_log2(blocksize >> EXT2_MIN_BLOCK_LOG_SIZE);
+
+	blocksize = EXT2_BLOCK_SIZE(&fs_param);
+	
+	if (extended_opts)
+		parse_extended_opts(&fs_param, extended_opts);
+
+	/* Since sparse_super is the default, we would only have a problem
+	 * here if it was explicitly disabled.
+	 */
+	if ((fs_param.s_feature_compat & EXT2_FEATURE_COMPAT_RESIZE_INODE) &&
+	    !(fs_param.s_feature_ro_compat&EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
+		com_err(program_name, 0,
+			_("reserved online resize blocks not supported "
+			  "on non-sparse filesystem"));
+		exit(1);
+	}
+
+	if (fs_param.s_blocks_per_group) {
+		if (fs_param.s_blocks_per_group < 256 ||
+		    fs_param.s_blocks_per_group > 8 * (unsigned) blocksize) {
 			com_err(program_name, 0,
 				_("blocks per group count out of range"));
 			exit(1);
 		}
 	}
 
+	if (!force && fs_param.s_blocks_count >= (1 << 31)) {
+		com_err(program_name, 0,
+			_("Filesystem too large.  No more than 2**31-1 blocks\n"
+			  "\t (8TB using a blocksize of 4k) are currently supported."));
+             exit(1);
+	}
+
+	if ((blocksize > 4096) &&
+	    (fs_param.s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL))
+		fprintf(stderr, _("\nWarning: some 2.4 kernels do not support "
+			"blocksizes greater than 4096\n\tusing ext3.  "
+			"Use -b 4096 if this is an issue for you.\n\n"));
+
+	if (inode_size) {
+		if (inode_size < EXT2_GOOD_OLD_INODE_SIZE ||
+		    inode_size > EXT2_BLOCK_SIZE(&fs_param) ||
+		    inode_size & (inode_size - 1)) {
+			com_err(program_name, 0,
+				_("invalid inode size %d (min %d/max %d)"),
+				inode_size, EXT2_GOOD_OLD_INODE_SIZE,
+				blocksize);
+			exit(1);
+		}
+		if (inode_size != EXT2_GOOD_OLD_INODE_SIZE)
+			fprintf(stderr, _("Warning: %d-byte inodes not usable "
+				"on most systems\n"),
+				inode_size);
+		fs_param.s_inode_size = inode_size;
+	}
+
 	/*
 	 * Calculate number of inodes based on the inode ratio
 	 */
-	param.s_inodes_count = num_inodes ? num_inodes : 
-		((__u64) param.s_blocks_count * EXT2_BLOCK_SIZE(&param))
+	fs_param.s_inodes_count = num_inodes ? num_inodes : 
+		((__u64) fs_param.s_blocks_count * blocksize)
 			/ inode_ratio;
 
 	/*
 	 * Calculate number of blocks to reserve
 	 */
-	param.s_r_blocks_count = (param.s_blocks_count * reserved_ratio) / 100;
-
-#ifdef EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER
-	if (sparse_option)
-		param_ext2->s_feature_ro_compat |=
-			EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER;
-#endif
-	if (feature_set && !strncasecmp(feature_set, "none", 4))
-		feature_set = NULL;
-	if (feature_set && e2p_edit_feature(feature_set,
-					    &param_ext2->s_feature_compat,
-					    ok_features)) {
-		fprintf(stderr, _("Invalid filesystem option set: %s\n"),
-			feature_set);
-		exit(1);
-	}
+	fs_param.s_r_blocks_count = (fs_param.s_blocks_count * reserved_ratio)
+		/ 100;
 }
-					
+
 int main (int argc, char *argv[])
 {
 	errcode_t	retval = 0;
 	ext2_filsys	fs;
 	badblocks_list	bb_list = 0;
-	struct ext2fs_sb *s;
+	int		journal_blocks;
+	unsigned int	i;
+	int		val;
+	io_manager	io_ptr;
 
 #ifdef ENABLE_NLS
 	setlocale(LC_MESSAGES, "");
+	setlocale(LC_CTYPE, "");
 	bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
 	textdomain(NLS_CAT_NAME);
 #endif
 	PRS(argc, argv);
 
+#ifdef CONFIG_TESTIO_DEBUG
+	io_ptr = test_io_manager;
+	test_io_backing_manager = unix_io_manager;
+#else
+	io_ptr = unix_io_manager;
+#endif
+
 	/*
 	 * Initialize the superblock....
 	 */
-	retval = ext2fs_initialize(device_name, 0, &param,
-				   unix_io_manager, &fs);
+	retval = ext2fs_initialize(device_name, EXT2_FLAG_EXCLUSIVE, &fs_param,
+				   io_ptr, &fs);
 	if (retval) {
 		com_err(device_name, retval, _("while setting up superblock"));
 		exit(1);
@@ -1037,13 +1482,28 @@ int main (int argc, char *argv[])
 	/*
 	 * Wipe out the old on-disk superblock
 	 */
-	zap_sector(fs, 2);
+	if (!noaction)
+		zap_sector(fs, 2, 6);
 
 	/*
 	 * Generate a UUID for it...
 	 */
-	s = (struct ext2fs_sb *) fs->super;
-	uuid_generate(s->s_uuid);
+	uuid_generate(fs->super->s_uuid);
+
+	/*
+	 * Initialize the directory index variables
+	 */
+	fs->super->s_def_hash_version = EXT2_HASH_TEA;
+	uuid_generate((unsigned char *) fs->super->s_hash_seed);
+
+	/*
+	 * Add "jitter" to the superblock's check interval so that we
+	 * don't check all the filesystems at the same time.  We use a
+	 * kludgy hack of using the UUID to derive a random jitter value.
+	 */
+	for (i = 0, val = 0 ; i < sizeof(fs->super->s_uuid); i++)
+		val += fs->super->s_uuid[i];
+	fs->super->s_max_mnt_count += val % EXT2_DFL_MAX_MNT_COUNT;
 
 	/*
 	 * Override the creator OS, if applicable
@@ -1065,18 +1525,20 @@ int main (int argc, char *argv[])
 	 * Set the volume label...
 	 */
 	if (volume_label) {
-		memset(s->s_volume_name, 0, sizeof(s->s_volume_name));
-		strncpy(s->s_volume_name, volume_label,
-			sizeof(s->s_volume_name));
+		memset(fs->super->s_volume_name, 0,
+		       sizeof(fs->super->s_volume_name));
+		strncpy(fs->super->s_volume_name, volume_label,
+			sizeof(fs->super->s_volume_name));
 	}
 
 	/*
 	 * Set the last mount directory
 	 */
 	if (mount_dir) {
-		memset(s->s_last_mounted, 0, sizeof(s->s_last_mounted));
-		strncpy(s->s_last_mounted, mount_dir,
-			sizeof(s->s_last_mounted));
+		memset(fs->super->s_last_mounted, 0,
+		       sizeof(fs->super->s_last_mounted));
+		strncpy(fs->super->s_last_mounted, mount_dir,
+			sizeof(fs->super->s_last_mounted));
 	}
 	
 	if (!quiet || noaction)
@@ -1085,6 +1547,12 @@ int main (int argc, char *argv[])
 	if (noaction)
 		exit(0);
 
+	if (fs->super->s_feature_incompat &
+	    EXT3_FEATURE_INCOMPAT_JOURNAL_DEV) {
+		create_journal_dev(fs);
+		exit(ext2fs_close(fs) ? 1 : 0);
+	}
+
 	if (bad_blocks_filename)
 		read_bb_file(fs, &bb_list, bad_blocks_filename);
 	if (cflag)
@@ -1102,25 +1570,122 @@ int main (int argc, char *argv[])
 		fs->super->s_state |= EXT2_ERROR_FS;
 		fs->flags &= ~(EXT2_FLAG_IB_DIRTY|EXT2_FLAG_BB_DIRTY);
 	} else {
+		/* rsv must be a power of two (64kB is MD RAID sb alignment) */
+		unsigned int rsv = 65536 / fs->blocksize;
+		unsigned long blocks = fs->super->s_blocks_count;
+		unsigned long start;
+		blk_t ret_blk;
+
+#ifdef ZAP_BOOTBLOCK
+		zap_sector(fs, 0, 2);
+#endif
+
+		/*
+		 * Wipe out any old MD RAID (or other) metadata at the end
+		 * of the device.  This will also verify that the device is
+		 * as large as we think.  Be careful with very small devices.
+		 */
+		start = (blocks & ~(rsv - 1));
+		if (start > rsv)
+			start -= rsv;
+		if (start > 0)
+			retval = zero_blocks(fs, start, blocks - start,
+					     NULL, &ret_blk, NULL);
+
+		if (retval) {
+			com_err(program_name, retval,
+				_("while zeroing block %u at end of filesystem"),
+				ret_blk);
+		}
+		setup_lazy_bg(fs);
 		write_inode_tables(fs);
 		create_root_dir(fs);
 		create_lost_and_found(fs);
 		reserve_inodes(fs);
 		create_bad_block_inode(fs, bb_list);
-#ifdef ZAP_BOOTBLOCK
-		zap_sector(fs, 0);
-#endif
+		if (fs->super->s_feature_compat & 
+		    EXT2_FEATURE_COMPAT_RESIZE_INODE) {
+			retval = ext2fs_create_resize_inode(fs);
+			if (retval) {
+				com_err("ext2fs_create_resize_inode", retval,
+				_("while reserving blocks for online resize"));
+				exit(1);
+			}
+		}
 	}
-	
+
+	if (journal_device) {
+		ext2_filsys	jfs;
+		
+		if (!force)
+			check_plausibility(journal_device); 
+		check_mount(journal_device, force, _("journal"));
+
+		retval = ext2fs_open(journal_device, EXT2_FLAG_RW|
+				     EXT2_FLAG_JOURNAL_DEV_OK, 0,
+				     fs->blocksize, unix_io_manager, &jfs);
+		if (retval) {
+			com_err(program_name, retval,
+				_("while trying to open journal device %s\n"),
+				journal_device);
+			exit(1);
+		}
+		if (!quiet) {
+			printf(_("Adding journal to device %s: "), 
+			       journal_device);
+			fflush(stdout);
+		}
+		retval = ext2fs_add_journal_device(fs, jfs);
+		if(retval) {
+			com_err (program_name, retval, 
+				 _("\n\twhile trying to add journal to device %s"), 
+				 journal_device);
+			exit(1);
+		}
+		if (!quiet)
+			printf(_("done\n"));
+		ext2fs_close(jfs);
+		free(journal_device);
+	} else if ((journal_size) ||
+		   (fs_param.s_feature_compat & 
+		    EXT3_FEATURE_COMPAT_HAS_JOURNAL)) {
+		journal_blocks = figure_journal_size(journal_size, fs);
+
+		if (!journal_blocks) {
+			fs->super->s_feature_compat &=
+				~EXT3_FEATURE_COMPAT_HAS_JOURNAL;
+			goto no_journal;
+		}
+		if (!quiet) {
+			printf(_("Creating journal (%d blocks): "),
+			       journal_blocks);
+			fflush(stdout);
+		}
+		retval = ext2fs_add_journal_inode(fs, journal_blocks,
+						  journal_flags);
+		if (retval) {
+			com_err (program_name, retval,
+				 _("\n\twhile trying to create journal"));
+			exit(1);
+		}
+		if (!quiet)
+			printf(_("done\n"));
+	}
+no_journal:
+
 	if (!quiet)
 		printf(_("Writing superblocks and "
 		       "filesystem accounting information: "));
 	retval = ext2fs_flush(fs);
 	if (retval) {
-		printf(_("\nWarning, had trouble writing out superblocks."));
+		fprintf(stderr,
+			_("\nWarning, had trouble writing out superblocks."));
 	}
-	if (!quiet)
-		printf(_("done\n"));
-	ext2fs_close(fs);
-	return 0;
+	if (!quiet) {
+		printf(_("done\n\n"));
+		if (!getenv("MKE2FS_SKIP_CHECK_MSG"))
+			print_check_message(fs);
+	}
+	val = ext2fs_close(fs);
+	return (retval || val) ? 1 : 0;
 }