.TP
.B "\-O \fIfeature\fR[,...]"
Create filesystem with given features (filesystem options), overriding
-the default filesystem options.
-Currently, the
-.B sparse_super
-and
-.B filetype
-features are turned on by default when
-.B mke2fs
-is run on a system with Linux 2.2 or later (unless creator-os is set to
-the Hurd). Filesystems that may need to be mounted on pre-2.2 Linux or
-other kernels should be created with
-.B "\-O none"
-(or
-.B "\-r 0"
-for Linux 1.2) which will disable these features, even if
-.B mke2fs
-is run on a system which can support them.
+the default filesystem options. The default features which are
+enabled by default are specified by the
+.I base_features
+relation, either in the
+.I [libdefaults]
+section in the
+.B /etc/mke2fs.conf
+configuration file, or in the subsection of the
+.I [fs_types]
+section for the filesystem type as specified by the
+.B -T
+option. The filesystem type-specific configuration setting found in
+the
+.I [fs_types]
+section will override the global default found in
+.IR [libdefaults] .
.sp
-The following filesystem options are supported:
+The filesystem feature set will be further edited
+using either the feature set specification specified by this option,
+or if this option is not specified, by the
+.I default_features
+relation for the filesystem type being created, or in the
+.I [libdefaults]
+section of the configuration file.
+.sp
+The filesystem feature set is comprised of a list of features, separated
+by commas, that are to be enabled. To disable a feature, simply
+prefix the feature name with a caret ('^') character. The
+pseudo-filesystem feature "none" will clear all filesystem features.
.RS 1.2i
.TP
.B dir_index
.BI \-T " fs-type"
Specify how the filesystem is going to be used, so that
.B mke2fs
-can choose optimal filesystem parameters for that use. Currently, the
-primary filesystem parameter which is manipulated is the number of
-inodes contained the filesystem, but in the future other filesystem
-parameters may also changed for specific filesystem usage scenarios. If
-no filesystem type is specified, filesystem meant for general purpose
-use will be created, with default values for the blocksize, number of
-inodes, etc. based on the size of the filesystem to be created. The
-supported filesystem types are:
-.RS 1.2i
-.TP 1.2i
-news
-one inode per 4kb block
-.TP
-largefile
-one inode per megabyte
-.TP
-largefile4
-one inode per 4 megabytes
-.RE
+can choose optimal filesystem parameters for that use, as defined
+filesystem type configuration settings found in the
+.BR /etc/mke2fs.conf (5)
+file.
.TP
.B \-v
Verbose execution.
is part of the e2fsprogs package and is available from
http://e2fsprogs.sourceforge.net.
.SH SEE ALSO
+.BR mke2fs.conf (5),
.BR badblocks (8),
.BR dumpe2fs (8),
.BR e2fsck (8),
#include "e2p/e2p.h"
#include "ext2fs/ext2fs.h"
#include "util.h"
+#include "profile.h"
#include "../version.h"
#include "nls-enable.h"
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;
return ((((major * 256) + minor) * 256) + rev);
}
-
-
-/*
- * 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.
- */
-#define DEF_MAX_BLOCKSIZE -1
-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 },
- { "journal", 0, 4096, 8192 },
- { "news", 0, 4096, 4096 },
- { "largefile", 0, 4096, 1024 * 1024 },
- { "largefile4", 0, 4096, 4096 * 1024 },
- { 0, 0, 0, 0},
-};
-
-static void set_fs_defaults(const char *fs_type,
- struct ext2_super_block *super,
- int blocksize, int sector_size,
- int *inode_ratio)
-{
- int megs;
- int ratio = 0;
- struct mke2fs_defaults *p;
- int use_bsize = 1024;
-
- 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 < blocksize ?
- blocksize : p->inode_ratio;
- use_bsize = p->blocksize;
- }
- if (blocksize <= 0) {
- if (use_bsize == DEF_MAX_BLOCKSIZE) {
- 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;
- super->s_blocks_count /= blocksize / 1024;
- }
- super->s_log_frag_size = super->s_log_block_size =
- int_log2(blocksize >> EXT2_MIN_BLOCK_LOG_SIZE);
-}
-
-
/*
* Helper function for read_bb_file and test_disk
*/
};
+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[] = { "/etc/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 b, c;
int size;
- char * tmp;
+ char *tmp, *tmp2;
int blocksize = 0;
int inode_ratio = 0;
int inode_size = 0;
struct utsname ut;
#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) {
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(&fs_param, 0, sizeof(struct ext2_super_block));
fs_param.s_rev_level = 1; /* Create revision 1 filesystems now */
- fs_param.s_feature_incompat |= EXT2_FEATURE_INCOMPAT_FILETYPE;
- fs_param.s_feature_ro_compat |= EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER;
-#if 0
- fs_param.s_feature_compat |= EXT2_FEATURE_COMPAT_DIR_INDEX;
-#endif
#ifdef __linux__
if (uname(&ut)) {
exit(1);
}
linux_version_code = parse_version_number(ut.release);
- if (linux_version_code && linux_version_code < (2*65536 + 2*256)) {
+ if (linux_version_code && linux_version_code < (2*65536 + 2*256))
fs_param.s_rev_level = 0;
- fs_param.s_feature_incompat = 0;
- fs_param.s_feature_compat = 0;
- fs_param.s_feature_ro_compat = 0;
- }
#endif
if (argc && *argv) {
parse_journal_opts(optarg);
break;
case 'j':
- fs_param.s_feature_compat |=
- EXT3_FEATURE_COMPAT_HAS_JOURNAL;
if (!journal_size)
journal_size = -1;
break;
quiet = 1;
break;
case 'r':
- fs_param.s_rev_level = strtoul(optarg, &tmp, 0);
+ r_opt = strtoul(optarg, &tmp, 0);
if (*tmp) {
com_err(program_name, 0,
_("bad revision level - %s"), optarg);
exit(1);
}
- 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;
- }
+ fs_param.s_rev_level = r_opt;
break;
case 's': /* deprecated */
- if (atoi(optarg))
- fs_param.s_feature_ro_compat |=
- EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER;
- else
- fs_param.s_feature_ro_compat &=
- ~EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER;
+ s_opt = atoi(optarg);
break;
#ifdef EXT2_DYNAMIC_REV
case 'I':
}
break;
case 'O':
- if (!strcmp(optarg, "none")) {
- fs_param.s_feature_compat = 0;
- fs_param.s_feature_incompat = 0;
- fs_param.s_feature_ro_compat = 0;
- break;
- }
- if (e2p_edit_feature(optarg,
- &fs_param.s_feature_compat,
- ok_features)) {
- fprintf(stderr,
- _("Invalid filesystem option set: %s\n"), optarg);
- exit(1);
- }
+ fs_features = optarg;
break;
case 'E':
case 'R':
"(max %d), forced to continue\n"),
blocksize, sys_page_size);
}
- 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 (optind < argc) {
fs_param.s_blocks_count = parse_num_blocks(argv[optind++],
fs_param.s_log_block_size);
if (optind < argc)
usage();
- 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_compat || fs_param.s_feature_ro_compat ||
- fs_param.s_feature_incompat))
- fs_param.s_rev_level = 1; /* Create a revision 1 filesystem */
-
if (!force)
check_plausibility(device_name);
check_mount(device_name, force, _("filesystem"));
proceed_question();
}
- /*
- * If the user asked for HAS_JOURNAL, then make sure a journal
- * gets created.
- */
- if ((fs_param.s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) &&
- !journal_size)
- journal_size = -1;
+ 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 ((tmp = getenv("MKE2FS_DEVICE_SECTSIZE")) != NULL)
sector_size = atoi(tmp);
- set_fs_defaults(fs_type, &fs_param, blocksize, sector_size,
- &inode_ratio);
+ 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 (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)
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) ||
printf(_("done\n"));
ext2fs_close(jfs);
free(journal_device);
- } else if (journal_size) {
+ } 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) {
--- /dev/null
+.\" -*- nroff -*-
+.\" Copyright 2006 by Theodore Ts'o. All Rights Reserved.
+.\" This file may be copied under the terms of the GNU Public License.
+.\"
+.TH mke2fs.conf 5 "@E2FSPROGS_MONTH@ @E2FSPROGS_YEAR@" "E2fsprogs version @E2FSPROGS_VERSION@"
+.SH NAME
+mke2fs.conf \- Configuration file for mke2fs
+.SH DESCRIPTION
+.I mke2fs.conf
+is the configuration file for
+.BR mke2fs (8).
+It controls the default parameters used by
+.BR mke2fs (8)
+when it is creating ext2 or ext3 filesystems.
+.PP
+The
+.I mke2fs.conf
+file uses an INI-style format. Sections are delimited by
+square braces: [ ]. Within each section, each line defines a
+relation, which assigns tags to values, or to a subsection,
+which contains further relations or subsections.
+.\" Tags can be assigned multiple values
+An example of the INI-style format used by this configuration file
+follows below:
+.P
+[section1]
+.br
+ tag1 = value_a
+.br
+ tag1 = value_b
+.br
+ tag2 = value_c
+.P
+[section 2]
+.br
+ tag3 = {
+.br
+ subtag1 = subtag_value_a
+.br
+ subtag1 = subtag_value_b
+.br
+ subtag2 = subtag_value_c
+.br
+ }
+.br
+ tag1 = value_d
+.br
+ tag2 = value_e
+.br
+}
+.P
+The following sections are used in the
+.I mke2fs.conf
+file. They will be described in more detail in future sections of this
+document.
+.TP
+.I [defaults]
+Contains relations which define the default parameters
+used by
+.BR mke2fs (8).
+In general, these defaults may be overridden by a definition in the
+.B fs_types
+section, or by an command-line option provided by the user.
+.TP
+.I [fs_types]
+Contains relations which define defaults that should be used for specific
+filesystem types. The filesystem type can be specified explicitly using
+the
+.B -T
+option to
+.BR mke2fs (8).
+If no filesystem type is specified,
+.BR mke2fs (8)
+will use the filesystem type
+.I floppy
+if the filesystem size is less than or equal to 3 megabytes.
+If the filesystem size is greater than 3 but less than or equal to
+512 megabytes,
+.BR mke2fs (8)
+will use the filesystem
+.IR small .
+Otherwise,
+.BR mke2fs (8)
+will use the default filesystem type
+.IR default .
+.SH THE [defaults] SECTION
+The following relations are defined in the
+.I [defaults]
+section.
+.TP
+.I base_features
+This relation specifies the filesystems features which are enabled in
+newly created filesystems. It may be overriden by the
+.I base_features
+relation found in the filesystem-type-specific subsection of
+the
+.I [fs_types]
+section.
+.TP
+.I default_features
+This relation specifies a set of features that should be added or
+removed to the features listed in the
+.I base_features
+relation. It may be overriden by the filesystem-specific
+.I default_features
+in the filesystem-type subection of
+.IR [fs_types] ,
+and by the
+.B -O
+command-line option
+to
+.BR mke2fs (8).
+.TP
+.I blocksize
+This relation specifies the default blocksize if the user does not
+specify a blocksize on the command line, and the filesystem-type
+specific section of the configuration file does not specify a blocksize.
+.TP
+.I inode_ratio
+This relation specifies the default inode ratio if the user does not
+specify one on the command line, and the filesystem-type
+specific section of the configuration file does not specify a default
+inode ratio.
+.SH THE [fs_types] SECTION
+Each tag in the
+.I [fs_types]
+section names a filesystem type which can be specified via the
+.B -T
+option to
+.BR mke2fs (8).
+The value of the tag is a subsection where the relations in that
+subsection define the defaults for that filesystem type. For
+example:
+.P
+[fs_types]
+.br
+ small = {
+.br
+ blocksize = 1024
+.br
+ inode_ratio = 4096
+.br
+ }
+.br
+ floppy = {
+.br
+ blocksize = 1024
+.br
+ }
+.P
+For each filesystem type, the following tag may be used in that
+fs_type's subsection:
+.TP
+.I base_features
+This relation specifies the features which are enabled for this
+filesystem type.
+.TP
+.I default_features
+This relation specifies set of features which should be enabled or
+disabled to the features listed in the
+.I base_features
+relation. It may be overriden by the
+.B -O
+command-line option to
+.BR mke2fs (8).
+.TP
+.I blocksize
+This relation specifies the default blocksize if the user does not
+specify a blocksize on the command line.
+.TP
+.I inode_ratio
+This relation specifies the default inode ratio if the user does not
+specify one on the command line.
+.SH FILES
+.TP
+.I /etc/mke2fs.conf
+The configuration file for
+.BR mke2fs (8).
+.SH SEE ALSO
+.BR mke2fs (8)
git://git.whamcloud.com / tools / e2fsprogs.git / commitdiff