#include "ext2fs/ext2fs.h"
#include "util.h"
#include "profile.h"
+#include "prof_err.h"
#include "../version.h"
#include "nls-enable.h"
static void usage(void)
{
fprintf(stderr, _("Usage: %s [-c|-t|-l filename] [-b block-size] "
- "[-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 options] [-qvSV] device [blocks-count]\n"),
+ "[-f fragment-size]\n\t[-i bytes-per-inode] [-I inode-size] "
+ "[-j] [-J journal-options]\n"
+ "\t[-N number-of-inodes] [-m reserved-blocks-percentage] "
+ "[-o creator-os]\n\t[-g blocks-per-group] [-L volume-label] "
+ "[-M last-mounted-directory]\n\t[-O feature[,...]] "
+ "[-r fs-revision] [-E extended-option[,...]] [-qvSV]\n\tdevice [blocks-count]\n"),
program_name);
exit(1);
}
errcode_t retval;
char buf[1024];
- sprintf(buf, "badblocks -b %d -X %s%s%s %d", fs->blocksize,
+ sprintf(buf, "badblocks -b %d -X %s%s%s %u", fs->blocksize,
quiet ? "" : "-s ", (cflag > 1) ? "-w " : "",
- fs->device_name, fs->super->s_blocks_count);
+ fs->device_name, fs->super->s_blocks_count-1);
if (verbose)
printf(_("Running command: %s\n"), buf);
f = popen(buf, "r");
if (ext2fs_badblocks_list_test(bb_list, i)) {
fprintf(stderr, _("Block %d in primary "
"superblock/group descriptor area bad.\n"), i);
- fprintf(stderr, _("Blocks %u through %d must be good "
+ fprintf(stderr, _("Blocks %u through %u must be good "
"in order to build a filesystem.\n"),
fs->super->s_first_data_block, must_be_good);
fputs(_("Aborting....\n"), stderr);
static void create_root_dir(ext2_filsys fs)
{
- errcode_t retval;
+ errcode_t retval;
struct ext2_inode inode;
+ __u32 uid, gid;
retval = ext2fs_mkdir(fs, EXT2_ROOT_INO, EXT2_ROOT_INO, 0);
if (retval) {
_("while reading root inode"));
exit(1);
}
- inode.i_uid = getuid();
- if (inode.i_uid)
- inode.i_gid = getgid();
+ uid = getuid();
+ inode.i_uid = uid;
+ ext2fs_set_i_uid_high(inode, uid >> 16);
+ if (uid) {
+ gid = getgid();
+ inode.i_gid = gid;
+ ext2fs_set_i_gid_high(inode, gid >> 16);
+ }
retval = ext2fs_write_new_inode(fs, EXT2_ROOT_INO, &inode);
if (retval) {
com_err("ext2fs_write_inode", retval,
static void parse_extended_opts(struct ext2_super_block *param,
const char *opts)
{
- char *buf, *token, *next, *p, *arg;
+ char *buf, *token, *next, *p, *arg, *badopt = "";
int len;
int r_usage = 0;
if (strcmp(token, "stride") == 0) {
if (!arg) {
r_usage++;
+ badopt = token;
continue;
}
- fs_stride = strtoul(arg, &p, 0);
- if (*p || (fs_stride == 0)) {
+ param->s_raid_stride = strtoul(arg, &p, 0);
+ if (*p || (param->s_raid_stride == 0)) {
fprintf(stderr,
_("Invalid stride parameter: %s\n"),
arg);
r_usage++;
continue;
}
+ } else if (strcmp(token, "stripe-width") == 0 ||
+ strcmp(token, "stripe_width") == 0) {
+ if (!arg) {
+ r_usage++;
+ badopt = token;
+ continue;
+ }
+ param->s_raid_stripe_width = strtoul(arg, &p, 0);
+ if (*p || (param->s_raid_stripe_width == 0)) {
+ fprintf(stderr,
+ _("Invalid stripe-width 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;
if (!arg) {
r_usage++;
+ badopt = token;
continue;
}
if (!bpg)
bpg = blocksize * 8;
gdpb = blocksize / sizeof(struct ext2_group_desc);
- group_desc_count = (param->s_blocks_count +
- bpg - 1) / bpg;
+ group_desc_count =
+ ext2fs_div_ceil(param->s_blocks_count, bpg);
desc_blocks = (group_desc_count +
gdpb - 1) / gdpb;
- rsv_groups = (resize + bpg - 1) / bpg;
- rsv_gdb = (rsv_groups + gdpb - 1) / gdpb -
+ rsv_groups = ext2fs_div_ceil(resize, bpg);
+ rsv_gdb = ext2fs_div_ceil(rsv_groups, gdpb) -
desc_blocks;
if (rsv_gdb > (int) EXT2_ADDR_PER_BLOCK(param))
rsv_gdb = EXT2_ADDR_PER_BLOCK(param);
if (rsv_gdb > 0) {
+ if (param->s_rev_level == EXT2_GOOD_OLD_REV) {
+ fprintf(stderr,
+ _("On-line resizing not supported with revision 0 filesystems\n"));
+ free(buf);
+ exit(1);
+ }
param->s_feature_compat |=
EXT2_FEATURE_COMPAT_RESIZE_INODE;
param->s_reserved_gdt_blocks = rsv_gdb;
}
- } else
+ } else if (!strcmp(token, "test_fs")) {
+ param->s_flags |= EXT2_FLAGS_TEST_FILESYS;
+ } else {
r_usage++;
+ badopt = token;
+ }
}
if (r_usage) {
- fprintf(stderr, _("\nBad options specified.\n\n"
+ fprintf(stderr, _("\nBad option(s) specified: %s\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 extended options are:\n"
- "\tstride=<stride length in blocks>\n"
- "\tresize=<resize maximum size in blocks>\n\n"));
+ "\tstride=<RAID per-disk data chunk in blocks>\n"
+ "\tstripe-width=<RAID stride * data disks in blocks>\n"
+ "\tresize=<resize maximum size in blocks>\n\n"
+ "\ttest_fs\n"),
+ badopt);
+ free(buf);
exit(1);
}
+ if (param->s_raid_stride &&
+ (param->s_raid_stripe_width % param->s_raid_stride) != 0)
+ fprintf(stderr, _("\nWarning: RAID stripe-width %u not an even "
+ "multiple of stride %u.\n\n"),
+ param->s_raid_stripe_width, param->s_raid_stride);
+
+ free(buf);
}
static __u32 ok_features[3] = {
+ /* Compat */
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 */
+ EXT2_FEATURE_COMPAT_LAZY_BG |
+ EXT2_FEATURE_COMPAT_EXT_ATTR,
+ /* Incompat */
+ EXT2_FEATURE_INCOMPAT_FILETYPE|
EXT3_FEATURE_INCOMPAT_JOURNAL_DEV|
EXT2_FEATURE_INCOMPAT_META_BG,
- EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER /* R/O compat */
+ /* R/O compat */
+ EXT2_FEATURE_RO_COMPAT_LARGE_FILE|
+ EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER
};
}
}
+extern const char *mke2fs_default_profile;
+static const char *default_files[] = { "<default>", 0 };
+
static void PRS(int argc, char *argv[])
{
int b, c;
double reserved_ratio = 5.0;
int sector_size = 0;
int show_version_only = 0;
- ext2_ino_t num_inodes = 0;
+ unsigned long long num_inodes = 0; /* unsigned long long to catch too-large input */
errcode_t retval;
char * oldpath = getenv("PATH");
char * extended_opts = 0;
int s_opt = -1, r_opt = -1;
char *fs_features = 0;
int use_bsize;
+ char *newpath;
+ int pathlen = sizeof(PATH_SET) + 1;
+
+ if (oldpath)
+ pathlen += strlen(oldpath);
+ newpath = malloc(pathlen);
+ strcpy(newpath, PATH_SET);
/* Update our PATH to include /sbin */
if (oldpath) {
- char *newpath;
-
- newpath = malloc(sizeof (PATH_SET) + 1 + strlen (oldpath));
- strcpy (newpath, PATH_SET);
strcat (newpath, ":");
strcat (newpath, oldpath);
- putenv (newpath);
- } else
- putenv (PATH_SET);
+ }
+ putenv (newpath);
tmp = getenv("MKE2FS_SYNC");
if (tmp)
if ((tmp = getenv("MKE2FS_CONFIG")) != NULL)
config_fn[0] = tmp;
profile_set_syntax_err_cb(syntax_err_report);
- profile_init(config_fn, &profile);
+ retval = profile_init(config_fn, &profile);
+ if (retval == ENOENT) {
+ profile_init(default_files, &profile);
+ profile_set_default(profile, mke2fs_default_profile);
+ }
setbuf(stdout, NULL);
setbuf(stderr, NULL);
- initialize_ext2_error_table();
+ add_error_table(&et_ext2_error_table);
+ add_error_table(&et_prof_error_table);
memset(&fs_param, 0, sizeof(struct ext2_super_block));
fs_param.s_rev_level = 1; /* Create revision 1 filesystems now */
case 's': /* deprecated */
s_opt = atoi(optarg);
break;
-#ifdef EXT2_DYNAMIC_REV
case 'I':
inode_size = strtoul(optarg, &tmp, 0);
if (*tmp) {
exit(1);
}
break;
-#endif
case 'v':
verbose = 1;
break;
case 'F':
- force = 1;
+ force++;
break;
case 'L':
volume_label = optarg;
}
if (!fs_type) {
- int megs = fs_param.s_blocks_count *
+ int megs = (__u64)fs_param.s_blocks_count *
(EXT2_BLOCK_SIZE(&fs_param) / 1024) / 1024;
- if (megs <= 3)
+ if (fs_param.s_feature_incompat &
+ EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)
+ fs_type = "journal";
+ else if (megs <= 3)
fs_type = "floppy";
else if (megs <= 512)
fs_type = "small";
/* Figure out what features should be enabled */
- if (r_opt == EXT2_GOOD_OLD_REV && fs_features) {
+ tmp = tmp2 = NULL;
+ if (fs_param.s_rev_level != EXT2_GOOD_OLD_REV) {
+ profile_get_string(profile, "defaults", "base_features", 0,
+ "sparse_super,filetype,resize_inode,dir_index",
+ &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);
+
+ tmp = tmp2 = NULL;
+ 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);
+ if (tmp)
+ free(tmp);
+ if (tmp2)
+ free(tmp2);
+
+ if (r_opt == EXT2_GOOD_OLD_REV &&
+ (fs_param.s_feature_compat || fs_param.s_feature_incompat ||
+ fs_param.s_feature_incompat)) {
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)
+ if (s_opt > 0) {
+ if (r_opt == EXT2_GOOD_OLD_REV) {
+ fprintf(stderr, _("Sparse superblocks not supported "
+ "with revision 0 filesystems\n"));
+ exit(1);
+ }
fs_param.s_feature_ro_compat |=
EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER;
- else if (s_opt == 0)
+ } else if (s_opt == 0)
fs_param.s_feature_ro_compat &=
~EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER;
- if (journal_size != 0)
+ if (journal_size != 0) {
+ if (r_opt == EXT2_GOOD_OLD_REV) {
+ fprintf(stderr, _("Journals not supported "
+ "with revision 0 filesystems\n"));
+ exit(1);
+ }
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) &&
if (blocksize <= 0) {
profile_get_integer(profile, "defaults", "blocksize", 0,
- 1024, &use_bsize);
+ 4096, &use_bsize);
profile_get_integer(profile, "fs_types", fs_type,
"blocksize", use_bsize, &use_bsize);
}
}
- if (!force && fs_param.s_blocks_count >= (1 << 31)) {
+ if (!force && fs_param.s_blocks_count >= ((unsigned) 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."));
"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 == 0) {
+ profile_get_integer(profile, "defaults", "inode_size", NULL,
+ 0, &inode_size);
+ profile_get_integer(profile, "fs_types", fs_type,
+ "inode_size", inode_size,
+ &inode_size);
+ }
+
+ if (inode_size && fs_param.s_rev_level >= EXT2_DYNAMIC_REV) {
if (inode_size < EXT2_GOOD_OLD_INODE_SIZE ||
inode_size > EXT2_BLOCK_SIZE(&fs_param) ||
inode_size & (inode_size - 1)) {
}
if (inode_size != EXT2_GOOD_OLD_INODE_SIZE)
fprintf(stderr, _("Warning: %d-byte inodes not usable "
- "on most systems\n"),
+ "on older systems\n"),
inode_size);
fs_param.s_inode_size = inode_size;
}
+ /* Make sure number of inodes specified will fit in 32 bits */
+ if (num_inodes == 0) {
+ unsigned long long n;
+ n = (unsigned long long) fs_param.s_blocks_count * blocksize / inode_ratio;
+ if (n > ~0U) {
+ com_err(program_name, 0,
+ _("too many inodes (%llu), raise inode ratio?"), n);
+ exit(1);
+ }
+ } else if (num_inodes > ~0U) {
+ com_err(program_name, 0,
+ _("too many inodes (%llu), specify < 2^32 inodes"),
+ num_inodes);
+ exit(1);
+ }
/*
* Calculate number of inodes based on the inode ratio
*/
((__u64) fs_param.s_blocks_count * blocksize)
/ inode_ratio;
+ if ((((long long)fs_param.s_inodes_count) *
+ (inode_size ? inode_size : EXT2_GOOD_OLD_INODE_SIZE)) >=
+ (((long long)fs_param.s_blocks_count) *
+ EXT2_BLOCK_SIZE(&fs_param))) {
+ com_err(program_name, 0, _("inode_size (%u) * inodes_count "
+ "(%u) too big for a\n\t"
+ "filesystem with %lu blocks, "
+ "specify higher inode_ratio (-i)\n\t"
+ "or lower inode count (-N).\n"),
+ inode_size ? inode_size : EXT2_GOOD_OLD_INODE_SIZE,
+ fs_param.s_inodes_count,
+ (unsigned long) fs_param.s_blocks_count);
+ exit(1);
+ }
+
/*
* Calculate number of blocks to reserve
*/
- fs_param.s_r_blocks_count = (fs_param.s_blocks_count * reserved_ratio)
- / 100;
+ fs_param.s_r_blocks_count = e2p_percent(reserved_ratio,
+ fs_param.s_blocks_count);
}
int main (int argc, char *argv[])
exit(1);
}
+ if (fs_param.s_flags & EXT2_FLAGS_TEST_FILESYS)
+ fs->super->s_flags |= EXT2_FLAGS_TEST_FILESYS;
+
/*
* Wipe out the old on-disk superblock
*/
test_disk(fs, &bb_list);
handle_bad_blocks(fs, bb_list);
- fs->stride = fs_stride;
+ fs->stride = fs_stride = fs->super->s_raid_stride;
retval = ext2fs_allocate_tables(fs);
if (retval) {
com_err(program_name, retval,
print_check_message(fs);
}
val = ext2fs_close(fs);
+ remove_error_table(&et_ext2_error_table);
+ remove_error_table(&et_prof_error_table);
return (retval || val) ? 1 : 0;
}
git://git.whamcloud.com / tools / e2fsprogs.git / blobdiff