X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=misc%2Fmke2fs.c;h=7ec8cc2f3cef6c2602030f03269bf390fb9d1d5e;hb=f1b53202b1b417e9fac064d6ecee4e20fa750ef4;hp=2d9107a96c3f7663857e194c878255c3067ed0f9;hpb=95bcea9fc149e349865f9eb30988ad1b4e1c1342;p=tools%2Fe2fsprogs.git diff --git a/misc/mke2fs.c b/misc/mke2fs.c index 2d9107a..7ec8cc2 100644 --- a/misc/mke2fs.c +++ b/misc/mke2fs.c @@ -18,6 +18,7 @@ #define _XOPEN_SOURCE 600 /* for inclusion of PATH_MAX in Solaris */ +#include "config.h" #include #include #include @@ -42,11 +43,9 @@ extern int optind; #ifdef HAVE_ERRNO_H #include #endif -#ifdef HAVE_MNTENT_H -#include -#endif #include #include +#include #include #include #include @@ -62,13 +61,18 @@ extern int optind; #include "prof_err.h" #include "../version.h" #include "nls-enable.h" +#include "quota/mkquota.h" #define STRIDE_LENGTH 8 +#define MAX_32_NUM ((((unsigned long long) 1) << 32) - 1) + #ifndef __sparc__ #define ZAP_BOOTBLOCK #endif +#define DISCARD_STEP_MB (2048) + extern int isatty(int); extern FILE *fpopen(const char *cmd, const char *mode); @@ -80,6 +84,8 @@ int cflag; int verbose; int quiet; int super_only; +int discard = 1; /* attempt to discard device before fs creation */ +int direct_io; int force; int noaction; int journal_size; @@ -87,6 +93,7 @@ int journal_flags; int lazy_itable_init; char *bad_blocks_filename; __u32 fs_stride; +int quotatype = -1; /* Initialize both user and group quotas by default */ struct ext2_super_block fs_param; char *fs_uuid = NULL; @@ -105,19 +112,20 @@ int linux_version_code = 0; static void usage(void) { fprintf(stderr, _("Usage: %s [-c|-l filename] [-b block-size] " - "[-f fragment-size]\n\t[-i bytes-per-inode] [-I inode-size] " + "[-C cluster-size]\n\t[-i bytes-per-inode] [-I inode-size] " "[-J journal-options]\n" - "\t[-G meta group size] [-N number-of-inodes]\n" + "\t[-G flex-group-size] [-N number-of-inodes]\n" "\t[-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[,...]]\n" - "\t[-T fs-type] [-U UUID] [-jnqvFSV] device [blocks-count]\n"), + "\t[-t fs-type] [-T usage-type ] [-U UUID] " + "[-jnqvDFKSV] device [blocks-count]\n"), program_name); exit(1); } -static int int_log2(int arg) +static int int_log2(unsigned long long arg) { int l = 0; @@ -129,7 +137,7 @@ static int int_log2(int arg) return l; } -static int int_log10(unsigned int arg) +static int int_log10(unsigned long long arg) { int l; @@ -273,8 +281,8 @@ _("Warning: the backup superblock/group descriptors at block %u contain\n" " bad blocks.\n\n"), group_block); group_bad++; - group = ext2fs_group_of_blk(fs, group_block+j); - fs->group_desc[group].bg_free_blocks_count++; + group = ext2fs_group_of_blk2(fs, group_block+j); + ext2fs_bg_free_blocks_count_set(fs, group, ext2fs_bg_free_blocks_count(fs, group) + 1); ext2fs_group_desc_csum_set(fs, group); ext2fs_free_blocks_count_add(fs->super, 1); } @@ -292,16 +300,16 @@ _("Warning: the backup superblock/group descriptors at block %u contain\n" exit(1); } while (ext2fs_badblocks_list_iterate(bb_iter, &blk)) - ext2fs_mark_block_bitmap2(fs->block_map, blk); + ext2fs_mark_block_bitmap2(fs->block_map, EXT2FS_B2C(fs, blk)); ext2fs_badblocks_list_iterate_end(bb_iter); } -static void write_inode_tables(ext2_filsys fs, int lazy_flag) +static void write_inode_tables(ext2_filsys fs, int lazy_flag, int itable_zeroed) { errcode_t retval; - blk_t blk; + blk64_t blk; dgrp_t i; - int num, ipb; + int num; struct ext2fs_numeric_progress_struct progress; ext2fs_numeric_progress_init(fs, &progress, @@ -311,25 +319,23 @@ static void write_inode_tables(ext2_filsys fs, int lazy_flag) for (i = 0; i < fs->group_desc_count; i++) { ext2fs_numeric_progress_update(fs, &progress, i); - blk = fs->group_desc[i].bg_inode_table; + blk = ext2fs_inode_table_loc(fs, i); num = fs->inode_blocks_per_group; - if (lazy_flag) { - ipb = fs->blocksize / EXT2_INODE_SIZE(fs->super); - num = ((((fs->super->s_inodes_per_group - - fs->group_desc[i].bg_itable_unused) * - EXT2_INODE_SIZE(fs->super)) + - EXT2_BLOCK_SIZE(fs->super) - 1) / - EXT2_BLOCK_SIZE(fs->super)); - } else { + if (lazy_flag) + num = ext2fs_div_ceil((fs->super->s_inodes_per_group - + ext2fs_bg_itable_unused(fs, i)) * + EXT2_INODE_SIZE(fs->super), + EXT2_BLOCK_SIZE(fs->super)); + if (!lazy_flag || itable_zeroed) { /* The kernel doesn't need to zero the itable blocks */ - ext2fs_bg_flag_set(fs, i, EXT2_BG_INODE_ZEROED); + ext2fs_bg_flags_set(fs, i, EXT2_BG_INODE_ZEROED); ext2fs_group_desc_csum_set(fs, i); } - retval = ext2fs_zero_blocks(fs, blk, num, &blk, &num); + retval = ext2fs_zero_blocks2(fs, blk, num, &blk, &num); if (retval) { fprintf(stderr, _("\nCould not write %d " - "blocks in inode table starting at %u: %s\n"), + "blocks in inode table starting at %llu: %s\n"), num, blk, error_message(retval)); exit(1); } @@ -340,7 +346,7 @@ static void write_inode_tables(ext2_filsys fs, int lazy_flag) sync(); } } - ext2fs_zero_blocks(0, 0, 0, 0, 0); + ext2fs_zero_blocks2(0, 0, 0, 0, 0); ext2fs_numeric_progress_close(fs, &progress, _("done \n")); } @@ -489,7 +495,7 @@ static void create_journal_dev(ext2_filsys fs) struct ext2fs_numeric_progress_struct progress; errcode_t retval; char *buf; - blk_t blk, err_blk; + blk64_t blk, err_blk; int c, count, err_count; retval = ext2fs_create_journal_superblock(fs, @@ -499,6 +505,10 @@ static void create_journal_dev(ext2_filsys fs) _("while initializing journal superblock")); exit(1); } + + if (journal_flags & EXT2_MKJOURNAL_LAZYINIT) + goto write_superblock; + ext2fs_numeric_progress_init(fs, &progress, _("Zeroing journal device: "), ext2fs_blocks_count(fs->super)); @@ -509,11 +519,11 @@ static void create_journal_dev(ext2_filsys fs) c = 1024; else c = count; - retval = ext2fs_zero_blocks(fs, blk, c, &err_blk, &err_count); + retval = ext2fs_zero_blocks2(fs, blk, c, &err_blk, &err_count); if (retval) { com_err("create_journal_dev", retval, _("while zeroing journal device " - "(block %u, count %d)"), + "(block %llu, count %d)"), err_blk, err_count); exit(1); } @@ -521,8 +531,10 @@ static void create_journal_dev(ext2_filsys fs) count -= c; ext2fs_numeric_progress_update(fs, &progress, blk); } - ext2fs_zero_blocks(0, 0, 0, 0, 0); + ext2fs_zero_blocks2(0, 0, 0, 0, 0); + ext2fs_numeric_progress_close(fs, &progress, NULL); +write_superblock: retval = io_channel_write_blk64(fs->io, fs->super->s_first_data_block+1, 1, buf); @@ -531,7 +543,6 @@ static void create_journal_dev(ext2_filsys fs) _("while writing journal superblock")); exit(1); } - ext2fs_numeric_progress_close(fs, &progress, NULL); } static void show_stats(ext2_filsys fs) @@ -539,7 +550,7 @@ static void show_stats(ext2_filsys fs) struct ext2_super_block *s = fs->super; char buf[80]; char *os; - blk_t group_block; + blk64_t group_block; dgrp_t i; int need, col_left; @@ -550,15 +561,20 @@ static void show_stats(ext2_filsys fs) memset(buf, 0, sizeof(buf)); strncpy(buf, s->s_volume_name, sizeof(s->s_volume_name)); printf(_("Filesystem label=%s\n"), buf); - fputs(_("OS type: "), stdout); - os = e2p_os2string(fs->super->s_creator_os); - fputs(os, stdout); + os = e2p_os2string(fs->super->s_creator_os); + if (os) + printf(_("OS type: %s\n"), os); free(os); - printf("\n"); printf(_("Block size=%u (log=%u)\n"), fs->blocksize, s->s_log_block_size); - printf(_("Fragment size=%u (log=%u)\n"), fs->fragsize, - s->s_log_frag_size); + if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super, + EXT4_FEATURE_RO_COMPAT_BIGALLOC)) + printf(_("Cluster size=%u (log=%u)\n"), + fs->blocksize << fs->cluster_ratio_bits, + s->s_log_cluster_size); + else + printf(_("Fragment size=%u (log=%u)\n"), EXT2_CLUSTER_SIZE(s), + s->s_log_cluster_size); printf(_("Stride=%u blocks, Stripe width=%u blocks\n"), s->s_raid_stride, s->s_raid_stripe_width); printf(_("%u inodes, %llu blocks\n"), s->s_inodes_count, @@ -575,8 +591,13 @@ static void show_stats(ext2_filsys fs) printf(_("%u block groups\n"), fs->group_desc_count); else 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); + if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super, + EXT4_FEATURE_RO_COMPAT_BIGALLOC)) + printf(_("%u blocks per group, %u clusters per group\n"), + s->s_blocks_per_group, s->s_clusters_per_group); + else + printf(_("%u blocks per group, %u fragments per group\n"), + s->s_blocks_per_group, s->s_clusters_per_group); printf(_("%u inodes per group\n"), s->s_inodes_per_group); if (fs->group_desc_count == 1) { @@ -599,7 +620,7 @@ static void show_stats(ext2_filsys fs) col_left = 72; } col_left -= need; - printf("%u", group_block); + printf("%llu", group_block); } printf("\n\n"); } @@ -654,14 +675,28 @@ static void parse_extended_opts(struct ext2_super_block *param, *arg = 0; arg++; } - if (strcmp(token, "stride") == 0) { + if (strcmp(token, "mmp_update_interval") == 0) { + if (!arg) { + r_usage++; + badopt = token; + continue; + } + param->s_mmp_update_interval = strtoul(arg, &p, 0); + if (*p) { + fprintf(stderr, + _("Invalid mmp_update_interval: %s\n"), + arg); + r_usage++; + continue; + } + } else if (strcmp(token, "stride") == 0) { if (!arg) { r_usage++; badopt = token; continue; } param->s_raid_stride = strtoul(arg, &p, 0); - if (*p || (param->s_raid_stride == 0)) { + if (*p) { fprintf(stderr, _("Invalid stride parameter: %s\n"), arg); @@ -676,7 +711,7 @@ static void parse_extended_opts(struct ext2_super_block *param, continue; } param->s_raid_stripe_width = strtoul(arg, &p, 0); - if (*p || (param->s_raid_stripe_width == 0)) { + if (*p) { fprintf(stderr, _("Invalid stripe-width parameter: %s\n"), arg); @@ -684,7 +719,8 @@ static void parse_extended_opts(struct ext2_super_block *param, continue; } } else if (!strcmp(token, "resize")) { - unsigned long resize, bpg, rsv_groups; + blk64_t resize; + unsigned long bpg, rsv_groups; unsigned long group_desc_count, desc_blocks; unsigned int gdpb, blocksize; int rsv_gdb; @@ -695,8 +731,8 @@ static void parse_extended_opts(struct ext2_super_block *param, continue; } - resize = parse_num_blocks(arg, - param->s_log_block_size); + resize = parse_num_blocks2(arg, + param->s_log_block_size); if (resize == 0) { fprintf(stderr, @@ -722,7 +758,7 @@ static void parse_extended_opts(struct ext2_super_block *param, ext2fs_blocks_count(param), bpg); desc_blocks = (group_desc_count + gdpb - 1) / gdpb; - rsv_groups = ext2fs_div_ceil(resize, bpg); + rsv_groups = ext2fs_div64_ceil(resize, bpg); rsv_gdb = ext2fs_div_ceil(rsv_groups, gdpb) - desc_blocks; if (rsv_gdb > (int) EXT2_ADDR_PER_BLOCK(param)) @@ -747,6 +783,33 @@ static void parse_extended_opts(struct ext2_super_block *param, lazy_itable_init = strtoul(arg, &p, 0); else lazy_itable_init = 1; + } else if (!strcmp(token, "lazy_journal_init")) { + if (arg) + journal_flags |= strtoul(arg, &p, 0) ? + EXT2_MKJOURNAL_LAZYINIT : 0; + else + journal_flags |= EXT2_MKJOURNAL_LAZYINIT; + } else if (!strcmp(token, "discard")) { + discard = 1; + } else if (!strcmp(token, "nodiscard")) { + discard = 0; + } else if (!strcmp(token, "quotatype")) { + if (!arg) { + r_usage++; + badopt = token; + continue; + } + if (!strncmp(arg, "usr", 3)) { + quotatype = 0; + } else if (!strncmp(arg, "grp", 3)) { + quotatype = 1; + } else { + fprintf(stderr, + _("Invalid quotatype parameter: %s\n"), + arg); + r_usage++; + continue; + } } else { r_usage++; badopt = token; @@ -762,7 +825,11 @@ static void parse_extended_opts(struct ext2_super_block *param, "\tstripe-width=\n" "\tresize=\n" "\tlazy_itable_init=<0 to disable, 1 to enable>\n" - "\ttest_fs\n\n"), + "\tlazy_journal_init=<0 to disable, 1 to enable>\n" + "\ttest_fs\n" + "\tdiscard\n" + "\tnodiscard\n" + "\tquotatype=\n\n"), badopt ? badopt : ""); free(buf); exit(1); @@ -787,14 +854,21 @@ static __u32 ok_features[3] = { EXT3_FEATURE_INCOMPAT_EXTENTS| EXT3_FEATURE_INCOMPAT_JOURNAL_DEV| EXT2_FEATURE_INCOMPAT_META_BG| - EXT4_FEATURE_INCOMPAT_FLEX_BG, + EXT4_FEATURE_INCOMPAT_FLEX_BG| + EXT4_FEATURE_INCOMPAT_MMP | + EXT4_FEATURE_INCOMPAT_64BIT, /* R/O compat */ EXT2_FEATURE_RO_COMPAT_LARGE_FILE| EXT4_FEATURE_RO_COMPAT_HUGE_FILE| EXT4_FEATURE_RO_COMPAT_DIR_NLINK| EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE| EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER| - EXT4_FEATURE_RO_COMPAT_GDT_CSUM + EXT4_FEATURE_RO_COMPAT_GDT_CSUM| + EXT4_FEATURE_RO_COMPAT_BIGALLOC| +#ifdef CONFIG_QUOTA + EXT4_FEATURE_RO_COMPAT_QUOTA| +#endif + 0 }; @@ -820,6 +894,18 @@ static void edit_feature(const char *str, __u32 *compat_array) } } +static void edit_mntopts(const char *str, __u32 *mntopts) +{ + if (!str) + return; + + if (e2p_edit_mntopts(str, mntopts, ~0)) { + fprintf(stderr, _("Invalid mount option set: %s\n"), + str); + exit(1); + } +} + struct str_list { char **list; int num; @@ -869,9 +955,39 @@ static void print_str_list(char **list) fputc('\n', stdout); } +/* + * Return TRUE if the profile has the given subsection + */ +static int profile_has_subsection(profile_t profile, const char *section, + const char *subsection) +{ + void *state; + const char *names[4]; + char *name; + int ret = 0; + + names[0] = section; + names[1] = subsection; + names[2] = 0; + + if (profile_iterator_create(profile, names, + PROFILE_ITER_LIST_SECTION | + PROFILE_ITER_RELATIONS_ONLY, &state)) + return 0; + + if ((profile_iterator(&state, &name, 0) == 0) && name) { + free(name); + ret = 1; + } + + profile_iterator_free(&state); + return ret; +} + static char **parse_fs_type(const char *fs_type, const char *usage_types, struct ext2_super_block *fs_param, + blk64_t fs_blocks_count, char *progname) { const char *ext_type = 0; @@ -880,7 +996,7 @@ static char **parse_fs_type(const char *fs_type, char *cp, *t; const char *size_type; struct str_list list; - unsigned long meg; + unsigned long long meg; int is_hurd = 0; if (init_list(&list)) @@ -896,6 +1012,8 @@ static char **parse_fs_type(const char *fs_type, ext_type = "ext2"; else if (!strcmp(program_name, "mke3fs")) ext_type = "ext3"; + else if (!strcmp(program_name, "mke4fs")) + ext_type = "ext4"; else if (progname) { ext_type = strrchr(progname, '/'); if (ext_type) @@ -919,40 +1037,43 @@ static char **parse_fs_type(const char *fs_type, ext_type = "ext3"; } - if (!strcmp(ext_type, "ext3") || !strcmp(ext_type, "ext4") || - !strcmp(ext_type, "ext4dev")) { - profile_get_string(profile, "fs_types", ext_type, "features", - 0, &t); - if (!t) { - printf(_("\nWarning! Your mke2fs.conf file does " - "not define the %s filesystem type.\n"), - ext_type); + + if (!profile_has_subsection(profile, "fs_types", ext_type) && + strcmp(ext_type, "ext2")) { + printf(_("\nYour mke2fs.conf file does not define the " + "%s filesystem type.\n"), ext_type); + if (!strcmp(ext_type, "ext3") || !strcmp(ext_type, "ext4") || + !strcmp(ext_type, "ext4dev")) { printf(_("You probably need to install an updated " "mke2fs.conf file.\n\n")); - sleep(5); + } + if (!force) { + printf(_("Aborting...\n")); + exit(1); } } meg = (1024 * 1024) / EXT2_BLOCK_SIZE(fs_param); - if (ext2fs_blocks_count(fs_param) < 3 * meg) + if (fs_blocks_count < 3 * meg) size_type = "floppy"; - else if (ext2fs_blocks_count(fs_param) < 512 * meg) + else if (fs_blocks_count < 512 * meg) size_type = "small"; - else + else if (fs_blocks_count < 4 * 1024 * 1024 * meg) size_type = "default"; + else if (fs_blocks_count < 16 * 1024 * 1024 * meg) + size_type = "big"; + else + size_type = "huge"; if (!usage_types) usage_types = size_type; - parse_str = malloc(usage_types ? strlen(usage_types)+1 : 1); + parse_str = malloc(strlen(usage_types)+1); if (!parse_str) { free(list.list); return 0; } - if (usage_types) - strcpy(parse_str, usage_types); - else - *parse_str = '\0'; + strcpy(parse_str, usage_types); if (ext_type) push_string(&list, ext_type); @@ -962,8 +1083,15 @@ static char **parse_fs_type(const char *fs_type, if (t) *t = '\0'; - if (*cp) - push_string(&list, cp); + if (*cp) { + if (profile_has_subsection(profile, "fs_types", cp)) + push_string(&list, cp); + else if (strcmp(cp, "default") != 0) + fprintf(stderr, + _("\nWarning: the fs_type %s is not " + "defined in mke2fs.conf\n\n"), + cp); + } if (t) cp = t+1; else { @@ -1006,6 +1134,18 @@ static int get_int_from_profile(char **fs_types, const char *opt, int def_val) return ret; } +static double get_double_from_profile(char **fs_types, const char *opt, + double def_val) +{ + double ret; + char **cpp; + + profile_get_double(profile, "defaults", opt, 0, def_val, &ret); + for (cpp = fs_types; *cpp; cpp++) + profile_get_double(profile, "fs_types", *cpp, opt, ret, &ret); + return ret; +} + static int get_bool_from_profile(char **fs_types, const char *opt, int def_val) { int ret; @@ -1025,8 +1165,9 @@ static const char *default_files[] = { "", 0 }; * Sets the geometry of a device (stripe/stride), and returns the * device's alignment offset, if any, or a negative error. */ -static int ext2fs_get_device_geometry(const char *file, - struct ext2_super_block *fs_param) +static int get_device_geometry(const char *file, + struct ext2_super_block *fs_param, + int psector_size) { int rc = -1; int blocksize; @@ -1034,6 +1175,11 @@ static int ext2fs_get_device_geometry(const char *file, blkid_topology tp; unsigned long min_io; unsigned long opt_io; + struct stat statbuf; + + /* Nothing to do for a regular file */ + if (!stat(file, &statbuf) && S_ISREG(statbuf.st_mode)) + return 0; pr = blkid_new_probe_from_filename(file); if (!pr) @@ -1046,9 +1192,18 @@ static int ext2fs_get_device_geometry(const char *file, min_io = blkid_topology_get_minimum_io_size(tp); opt_io = blkid_topology_get_optimal_io_size(tp); blocksize = EXT2_BLOCK_SIZE(fs_param); - - fs_param->s_raid_stride = min_io / blocksize; - fs_param->s_raid_stripe_width = opt_io / blocksize; + if ((min_io == 0) && (psector_size > blocksize)) + min_io = psector_size; + if ((opt_io == 0) && min_io) + opt_io = min_io; + if ((opt_io == 0) && (psector_size > blocksize)) + opt_io = psector_size; + + /* setting stripe/stride to blocksize is pointless */ + if (min_io > blocksize) + fs_param->s_raid_stride = min_io / blocksize; + if (opt_io > blocksize) + fs_param->s_raid_stripe_width = opt_io / blocksize; rc = blkid_topology_get_alignment_offset(tp); out: @@ -1060,22 +1215,23 @@ out: static void PRS(int argc, char *argv[]) { int b, c; - int size; + int cluster_size = 0; char *tmp, **cpp; int blocksize = 0; int inode_ratio = 0; int inode_size = 0; unsigned long flex_bg_size = 0; - double reserved_ratio = 5.0; - int sector_size = 0; + double reserved_ratio = -1.0; + int lsector_size = 0, psector_size = 0; int show_version_only = 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; - const char * fs_type = 0; - const char * usage_types = 0; - blk_t dev_size; + char * fs_type = 0; + char * usage_types = 0; + blk64_t dev_size; + blk64_t fs_blocks_count = 0; #ifdef __linux__ struct utsname ut; #endif @@ -1089,6 +1245,10 @@ static void PRS(int argc, char *argv[]) if (oldpath) pathlen += strlen(oldpath); newpath = malloc(pathlen); + if (!newpath) { + fprintf(stderr, _("Couldn't allocate memory for new PATH.\n")); + exit(1); + } strcpy(newpath, PATH_SET); /* Update our PATH to include /sbin */ @@ -1119,8 +1279,17 @@ static void PRS(int argc, char *argv[]) profile_set_syntax_err_cb(syntax_err_report); retval = profile_init(config_fn, &profile); if (retval == ENOENT) { - profile_init(default_files, &profile); - profile_set_default(profile, mke2fs_default_profile); + retval = profile_init(default_files, &profile); + if (retval) + goto profile_error; + retval = profile_set_default(profile, mke2fs_default_profile); + if (retval) + goto profile_error; + } else if (retval) { +profile_error: + fprintf(stderr, _("Couldn't init profile successfully" + " (error: %ld).\n"), retval); + exit(1); } setbuf(stdout, NULL); @@ -1150,7 +1319,7 @@ static void PRS(int argc, char *argv[]) } while ((c = getopt (argc, argv, - "b:cf:g:G:i:jl:m:no:qr:s:t:vE:FI:J:L:M:N:O:R:ST:U:V")) != EOF) { + "b:cg:i:jl:m:no:qr:s:t:vC:DE:FG:I:J:KL:M:N:O:R:ST:U:V")) != EOF) { switch (c) { case 'b': blocksize = strtol(optarg, &tmp, 0); @@ -1173,19 +1342,18 @@ static void PRS(int argc, char *argv[]) case 'c': /* Check for bad blocks */ cflag++; break; - case 'f': - size = strtoul(optarg, &tmp, 0); - if (size < EXT2_MIN_BLOCK_SIZE || - size > EXT2_MAX_BLOCK_SIZE || *tmp) { + case 'C': + cluster_size = strtoul(optarg, &tmp, 0); + if (cluster_size < EXT2_MIN_CLUSTER_SIZE || + cluster_size > EXT2_MAX_CLUSTER_SIZE || *tmp) { com_err(program_name, 0, - _("invalid fragment size - %s"), + _("invalid cluster size - %s"), optarg); exit(1); } - fs_param.s_log_frag_size = - int_log2(size >> EXT2_MIN_BLOCK_LOG_SIZE); - fprintf(stderr, _("Warning: fragments not supported. " - "Ignoring -f option\n")); + break; + case 'D': + direct_io = 1; break; case 'g': fs_param.s_blocks_per_group = strtoul(optarg, &tmp, 0); @@ -1207,7 +1375,7 @@ static void PRS(int argc, char *argv[]) _("Illegal number for flex_bg size")); exit(1); } - if (flex_bg_size < 2 || + if (flex_bg_size < 1 || (flex_bg_size & (flex_bg_size-1)) != 0) { com_err(program_name, 0, _("flex_bg size must be a power of 2")); @@ -1222,13 +1390,20 @@ static void PRS(int argc, char *argv[]) com_err(program_name, 0, _("invalid inode ratio %s (min %d/max %d)"), optarg, EXT2_MIN_BLOCK_SIZE, - EXT2_MAX_BLOCK_SIZE); + EXT2_MAX_BLOCK_SIZE * 1024); exit(1); } break; case 'J': parse_journal_opts(optarg); break; + case 'K': + fprintf(stderr, _("Warning: -K option is deprecated and " + "should not be used anymore. Use " + "\'-E nodiscard\' extended option " + "instead!\n")); + discard = 0; + break; case 'j': if (!journal_size) journal_size = -1; @@ -1312,10 +1487,20 @@ static void PRS(int argc, char *argv[]) super_only = 1; break; case 't': - fs_type = optarg; + if (fs_type) { + com_err(program_name, 0, + _("The -t option may only be used once")); + exit(1); + } + fs_type = strdup(optarg); break; case 'T': - usage_types = optarg; + if (usage_types) { + com_err(program_name, 0, + _("The -T option may only be used once")); + exit(1); + } + usage_types = strdup(optarg); break; case 'U': fs_uuid = optarg; @@ -1380,23 +1565,13 @@ static void PRS(int argc, char *argv[]) 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) { - ext2fs_blocks_count_set(&fs_param, parse_num_blocks(argv[optind++], - fs_param.s_log_block_size)); - if (!ext2fs_blocks_count(&fs_param)) { - com_err(program_name, 0, _("invalid blocks count - %s"), - argv[optind - 1]); + fs_blocks_count = parse_num_blocks2(argv[optind++], + fs_param.s_log_block_size); + if (!fs_blocks_count) { + com_err(program_name, 0, + _("invalid blocks '%s' on device '%s'"), + argv[optind - 1], device_name); exit(1); } } @@ -1407,54 +1582,21 @@ static void PRS(int argc, char *argv[]) check_plausibility(device_name); check_mount(device_name, force, _("filesystem")); - fs_param.s_log_frag_size = fs_param.s_log_block_size; - - if (noaction && ext2fs_blocks_count(&fs_param)) { - dev_size = ext2fs_blocks_count(&fs_param); + /* Determine the size of the device (if possible) */ + if (noaction && fs_blocks_count) { + dev_size = fs_blocks_count; retval = 0; - } else { - retry: - retval = ext2fs_get_device_size(device_name, - 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 == EFBIG) { - blk64_t big_dev_size; - - if (blocksize < 4096) { - fs_param.s_log_block_size = 2; - blocksize = 4096; - } + } else retval = ext2fs_get_device_size2(device_name, - EXT2_BLOCK_SIZE(&fs_param), &big_dev_size); - if (retval) - goto get_size_failure; - if (big_dev_size == (1ULL << 32)) { - dev_size = (blk_t) (big_dev_size - 1); - goto got_size; - } - fprintf(stderr, _("%s: Size of device %s too big " - "to be expressed in 32 bits\n\t" - "using a blocksize of %d.\n"), - program_name, device_name, EXT2_BLOCK_SIZE(&fs_param)); - exit(1); - } -get_size_failure: + EXT2_BLOCK_SIZE(&fs_param), + &dev_size); + if (retval && (retval != EXT2_ET_UNIMPLEMENTED)) { com_err(program_name, retval, _("while trying to determine filesystem size")); exit(1); } -got_size: - if (!ext2fs_blocks_count(&fs_param)) { + if (!fs_blocks_count) { if (retval == EXT2_ET_UNIMPLEMENTED) { com_err(program_name, 0, _("Couldn't determine device size; you " @@ -1474,22 +1616,32 @@ got_size: )); exit(1); } - ext2fs_blocks_count_set(&fs_param, dev_size); - if (sys_page_size > EXT2_BLOCK_SIZE(&fs_param)) { - blk64_t tmp = ext2fs_blocks_count(&fs_param); - - tmp &= ~((blk64_t) ((sys_page_size / + fs_blocks_count = dev_size; + if (sys_page_size > EXT2_BLOCK_SIZE(&fs_param)) + fs_blocks_count &= ~((blk64_t) ((sys_page_size / EXT2_BLOCK_SIZE(&fs_param))-1)); - ext2fs_blocks_count_set(&fs_param, tmp); - } } - } else if (!force && (ext2fs_blocks_count(&fs_param) > dev_size)) { + } else if (!force && (fs_blocks_count > dev_size)) { com_err(program_name, 0, _("Filesystem larger than apparent device size.")); proceed_question(); } - fs_types = parse_fs_type(fs_type, usage_types, &fs_param, argv[0]); + if (!fs_type) + profile_get_string(profile, "devices", device_name, + "fs_type", 0, &fs_type); + if (!usage_types) + profile_get_string(profile, "devices", device_name, + "usage_types", 0, &usage_types); + + /* + * We have the file system (or device) size, so we can now + * determine the appropriate file system types so the fs can + * be appropriately configured. + */ + fs_types = parse_fs_type(fs_type, usage_types, &fs_param, + fs_blocks_count ? fs_blocks_count : dev_size, + argv[0]); if (!fs_types) { fprintf(stderr, _("Failed to parse fs types list\n")); exit(1); @@ -1504,20 +1656,56 @@ got_size: edit_feature(tmp, &fs_param.s_feature_compat); free(tmp); + /* And which mount options as well */ + tmp = get_string_from_profile(fs_types, "default_mntopts", + "acl,user_xattr"); + edit_mntopts(tmp, &fs_param.s_default_mount_opts); + if (tmp) + free(tmp); + for (cpp = fs_types; *cpp; cpp++) { tmp = NULL; profile_get_string(profile, "fs_types", *cpp, "features", "", &tmp); if (tmp && *tmp) edit_feature(tmp, &fs_param.s_feature_compat); - free(tmp); + if (tmp) + free(tmp); } tmp = get_string_from_profile(fs_types, "default_features", ""); } edit_feature(fs_features ? fs_features : tmp, &fs_param.s_feature_compat); - free(tmp); + if (tmp) + free(tmp); + + /* + * We now need to do a sanity check of fs_blocks_count for + * 32-bit vs 64-bit block number support. + */ + if ((fs_blocks_count > MAX_32_NUM) && (blocksize == 0)) { + fs_blocks_count /= 4; /* Try using a 4k blocksize */ + blocksize = 4096; + fs_param.s_log_block_size = 2; + } + if ((fs_blocks_count > MAX_32_NUM) && + !(fs_param.s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT) && + get_bool_from_profile(fs_types, "auto_64-bit_support", 0)) { + fs_param.s_feature_incompat |= EXT4_FEATURE_INCOMPAT_64BIT; + fs_param.s_feature_compat &= ~EXT2_FEATURE_COMPAT_RESIZE_INODE; + } + if ((fs_blocks_count > MAX_32_NUM) && + !(fs_param.s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)) { + fprintf(stderr, _("%s: Size of device (0x%llx blocks) %s " + "too big to be expressed\n\t" + "in 32 bits using a blocksize of %d.\n"), + program_name, fs_blocks_count, device_name, + EXT2_BLOCK_SIZE(&fs_param)); + exit(1); + } + + ext2fs_blocks_count_set(&fs_param, fs_blocks_count); if (fs_param.s_feature_incompat & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV) { fs_types[0] = strdup("journal"); @@ -1559,6 +1747,18 @@ got_size: EXT3_FEATURE_COMPAT_HAS_JOURNAL; } + /* Get reserved_ratio from profile if not specified on cmd line. */ + if (reserved_ratio < 0.0) { + reserved_ratio = get_double_from_profile( + fs_types, "reserved_ratio", 5.0); + if (reserved_ratio > 50 || reserved_ratio < 0) { + com_err(program_name, 0, + _("invalid reserved blocks percent - %lf"), + reserved_ratio); + exit(1); + } + } + if (fs_param.s_feature_incompat & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV) { reserved_ratio = 0; @@ -1582,16 +1782,28 @@ got_size: ((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, §or_size); + /* Get the hardware sector sizes, if available */ + retval = ext2fs_get_device_sectsize(device_name, &lsector_size); if (retval) { com_err(program_name, retval, _("while trying to determine hardware sector size")); exit(1); } + retval = ext2fs_get_device_phys_sectsize(device_name, &psector_size); + if (retval) { + com_err(program_name, retval, + _("while trying to determine physical sector size")); + exit(1); + } if ((tmp = getenv("MKE2FS_DEVICE_SECTSIZE")) != NULL) - sector_size = atoi(tmp); + lsector_size = atoi(tmp); + if ((tmp = getenv("MKE2FS_DEVICE_PHYS_SECTSIZE")) != NULL) + psector_size = atoi(tmp); + + /* Older kernels may not have physical/logical distinction */ + if (!psector_size) + psector_size = lsector_size; if (blocksize <= 0) { use_bsize = get_int_from_profile(fs_types, "blocksize", 4096); @@ -1602,45 +1814,90 @@ got_size: (use_bsize > 4096)) use_bsize = 4096; } - if (sector_size && use_bsize < sector_size) - use_bsize = sector_size; + if (lsector_size && use_bsize < lsector_size) + use_bsize = lsector_size; if ((blocksize < 0) && (use_bsize < (-blocksize))) use_bsize = -blocksize; blocksize = use_bsize; ext2fs_blocks_count_set(&fs_param, ext2fs_blocks_count(&fs_param) / (blocksize / 1024)); + } else { + if (blocksize < lsector_size) { /* Impossible */ + com_err(program_name, EINVAL, + _("while setting blocksize; too small " + "for device\n")); + exit(1); + } else if ((blocksize < psector_size) && + (psector_size <= sys_page_size)) { /* Suboptimal */ + fprintf(stderr, _("Warning: specified blocksize %d is " + "less than device physical sectorsize %d\n"), + blocksize, psector_size); + } } + fs_param.s_log_block_size = + int_log2(blocksize >> EXT2_MIN_BLOCK_LOG_SIZE); + if (fs_param.s_feature_ro_compat & EXT4_FEATURE_RO_COMPAT_BIGALLOC) { + if (!cluster_size) + cluster_size = get_int_from_profile(fs_types, + "cluster_size", + blocksize*16); + fs_param.s_log_cluster_size = + int_log2(cluster_size >> EXT2_MIN_CLUSTER_LOG_SIZE); + } else + fs_param.s_log_cluster_size = fs_param.s_log_block_size; + if (inode_ratio == 0) { inode_ratio = get_int_from_profile(fs_types, "inode_ratio", 8192); if (inode_ratio < blocksize) inode_ratio = blocksize; + if (inode_ratio < EXT2_CLUSTER_SIZE(&fs_param)) + inode_ratio = EXT2_CLUSTER_SIZE(&fs_param); } - fs_param.s_log_frag_size = fs_param.s_log_block_size = - int_log2(blocksize >> EXT2_MIN_BLOCK_LOG_SIZE); - #ifdef HAVE_BLKID_PROBE_GET_TOPOLOGY - retval = ext2fs_get_device_geometry(device_name, &fs_param); + retval = get_device_geometry(device_name, &fs_param, psector_size); if (retval < 0) { fprintf(stderr, - _("warning: Unable to get device geometry for %s"), + _("warning: Unable to get device geometry for %s\n"), device_name); } else if (retval) { printf(_("%s alignment is offset by %lu bytes.\n"), device_name, retval); printf(_("This may result in very poor performance, " "(re)-partitioning suggested.\n")); - proceed_question(); } #endif blocksize = EXT2_BLOCK_SIZE(&fs_param); + /* This check should happen beyond the last assignment to blocksize */ + 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); + } + + lazy_itable_init = 0; + if (access("/sys/fs/ext4/features/lazy_itable_init", R_OK) == 0) + lazy_itable_init = 1; + lazy_itable_init = get_bool_from_profile(fs_types, - "lazy_itable_init", 0); + "lazy_itable_init", + lazy_itable_init); + discard = get_bool_from_profile(fs_types, "discard" , discard); + journal_flags |= get_bool_from_profile(fs_types, + "lazy_journal_init", 0) ? + EXT2_MKJOURNAL_LAZYINIT : 0; + journal_flags |= EXT2_MKJOURNAL_NO_MNT_CHECK; /* Get options from profile */ for (cpp = fs_types; *cpp; cpp++) { @@ -1708,12 +1965,18 @@ got_size: if (num_inodes == 0) { unsigned long long n; n = ext2fs_blocks_count(&fs_param) * blocksize / inode_ratio; - if (n > ~0U) { - com_err(program_name, 0, - _("too many inodes (%llu), raise inode ratio?"), n); - exit(1); + if (n > MAX_32_NUM) { + if (fs_param.s_feature_incompat & + EXT4_FEATURE_INCOMPAT_64BIT) + num_inodes = MAX_32_NUM; + else { + com_err(program_name, 0, + _("too many inodes (%llu), raise " + "inode ratio?"), n); + exit(1); + } } - } else if (num_inodes > ~0U) { + } else if (num_inodes > MAX_32_NUM) { com_err(program_name, 0, _("too many inodes (%llu), specify < 2^32 inodes"), num_inodes); @@ -1745,6 +2008,9 @@ got_size: */ ext2fs_r_blocks_count_set(&fs_param, reserved_ratio * ext2fs_blocks_count(&fs_param) / 100.0); + + free(fs_type); + free(usage_types); } static int should_do_undo(const char *name) @@ -1800,79 +2066,178 @@ open_err_out: static int mke2fs_setup_tdb(const char *name, io_manager *io_ptr) { - errcode_t retval = 0; - char *tdb_dir, *tdb_file; + errcode_t retval = ENOMEM; + char *tdb_dir = NULL, *tdb_file = NULL; char *device_name, *tmp_name; + int free_tdb_dir = 0; /* * Configuration via a conf file would be * nice */ tdb_dir = getenv("E2FSPROGS_UNDO_DIR"); - if (!tdb_dir) + if (!tdb_dir) { profile_get_string(profile, "defaults", "undo_dir", 0, "/var/lib/e2fsprogs", &tdb_dir); + free_tdb_dir = 1; + } if (!strcmp(tdb_dir, "none") || (tdb_dir[0] == 0) || access(tdb_dir, W_OK)) return 0; tmp_name = strdup(name); - if (!tmp_name) { - alloc_fn_fail: - com_err(program_name, ENOMEM, - _("Couldn't allocate memory for tdb filename\n")); - return ENOMEM; - } + if (!tmp_name) + goto errout; device_name = basename(tmp_name); tdb_file = malloc(strlen(tdb_dir) + 8 + strlen(device_name) + 7 + 1); - if (!tdb_file) - goto alloc_fn_fail; + if (!tdb_file) { + free(tmp_name); + goto errout; + } sprintf(tdb_file, "%s/mke2fs-%s.e2undo", tdb_dir, device_name); + free(tmp_name); if (!access(tdb_file, F_OK)) { if (unlink(tdb_file) < 0) { retval = errno; - com_err(program_name, retval, - _("while trying to delete %s"), - tdb_file); - free(tdb_file); - return retval; + goto errout; } } set_undo_io_backing_manager(*io_ptr); *io_ptr = undo_io_manager; - set_undo_io_backup_file(tdb_file); + retval = set_undo_io_backup_file(tdb_file); + if (retval) + goto errout; printf(_("Overwriting existing filesystem; this can be undone " "using the command:\n" " e2undo %s %s\n\n"), tdb_file, name); + if (free_tdb_dir) + free(tdb_dir); free(tdb_file); - free(tmp_name); + return 0; + +errout: + if (free_tdb_dir) + free(tdb_dir); + free(tdb_file); + com_err(program_name, retval, + _("while trying to setup undo file\n")); + return retval; +} + +static int mke2fs_discard_device(ext2_filsys fs) +{ + struct ext2fs_numeric_progress_struct progress; + blk64_t blocks = ext2fs_blocks_count(fs->super); + blk64_t count = DISCARD_STEP_MB; + blk64_t cur; + int retval = 0; + + /* + * Let's try if discard really works on the device, so + * we do not print numeric progress resulting in failure + * afterwards. + */ + retval = io_channel_discard(fs->io, 0, fs->blocksize); + if (retval) + return retval; + cur = fs->blocksize; + + count *= (1024 * 1024); + count /= fs->blocksize; + + ext2fs_numeric_progress_init(fs, &progress, + _("Discarding device blocks: "), + blocks); + while (cur < blocks) { + ext2fs_numeric_progress_update(fs, &progress, cur); + + if (cur + count > blocks) + count = blocks - cur; + + retval = io_channel_discard(fs->io, cur, count); + if (retval) + break; + cur += count; + } + + if (retval) { + ext2fs_numeric_progress_close(fs, &progress, + _("failed - ")); + if (!quiet) + printf("%s\n",error_message(retval)); + } else + ext2fs_numeric_progress_close(fs, &progress, + _("done \n")); + return retval; } +static void fix_cluster_bg_counts(ext2_filsys fs) +{ + blk64_t cluster, num_clusters, tot_free; + int grp_free, num_free, group, num; + + num_clusters = EXT2FS_B2C(fs, ext2fs_blocks_count(fs->super)); + tot_free = num_free = num = group = grp_free = 0; + for (cluster = EXT2FS_B2C(fs, fs->super->s_first_data_block); + cluster < num_clusters; cluster++) { + if (!ext2fs_test_block_bitmap2(fs->block_map, + EXT2FS_C2B(fs, cluster))) { + grp_free++; + tot_free++; + } + num++; + if ((num == fs->super->s_clusters_per_group) || + (cluster == num_clusters-1)) { + ext2fs_bg_free_blocks_count_set(fs, group, grp_free); + ext2fs_group_desc_csum_set(fs, group); + num = 0; + grp_free = 0; + group++; + } + } + ext2fs_free_blocks_count_set(fs->super, EXT2FS_C2B(fs, tot_free)); +} + +static int create_quota_inodes(ext2_filsys fs) +{ + quota_ctx_t qctx; + + quota_init_context(&qctx, fs, -1); + quota_compute_usage(qctx); + quota_write_inode(qctx, quotatype); + quota_release_context(&qctx); + + return 0; +} + int main (int argc, char *argv[]) { errcode_t retval = 0; ext2_filsys fs; badblocks_list bb_list = 0; unsigned int journal_blocks; - unsigned int i; + unsigned int i, checkinterval; + int max_mnt_count; int val, hash_alg; int flags; int old_bitmaps; io_manager io_ptr; char tdb_string[40]; char *hash_alg_str; + int itable_zeroed = 0; #ifdef ENABLE_NLS setlocale(LC_MESSAGES, ""); setlocale(LC_CTYPE, ""); bindtextdomain(NLS_CAT_NAME, LOCALEDIR); textdomain(NLS_CAT_NAME); + set_com_err_gettext(gettext); #endif PRS(argc, argv); @@ -1894,6 +2259,8 @@ int main (int argc, char *argv[]) * Initialize the superblock.... */ flags = EXT2_FLAG_EXCLUSIVE; + if (direct_io) + flags |= EXT2_FLAG_DIRECT_IO; profile_get_boolean(profile, "options", "old_bitmaps", 0, 0, &old_bitmaps); if (!old_bitmaps) @@ -1911,6 +2278,18 @@ int main (int argc, char *argv[]) exit(1); } + /* Can't undo discard ... */ + if (!noaction && discard && (io_ptr != undo_io_manager)) { + retval = mke2fs_discard_device(fs); + if (!retval && io_channel_discard_zeroes_data(fs->io)) { + if (verbose) + printf(_("Discard succeeded and will return 0s " + " - skipping inode table wipe\n")); + lazy_itable_init = 1; + itable_zeroed = 1; + } + } + sprintf(tdb_string, "tdb_data_size=%d", fs->blocksize <= 4096 ? 32768 : fs->blocksize * 8); io_channel_set_options(fs->io, tdb_string); @@ -1950,18 +2329,38 @@ int main (int argc, char *argv[]) hash_alg_str = get_string_from_profile(fs_types, "hash_alg", "half_md4"); hash_alg = e2p_string2hash(hash_alg_str); + free(hash_alg_str); fs->super->s_def_hash_version = (hash_alg >= 0) ? hash_alg : EXT2_HASH_HALF_MD4; 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. + * Periodic checks can be enabled/disabled via config file. + * Note we override the kernel include file's idea of what the default + * check interval (never) should be. It's a good idea to check at + * least *occasionally*, specially since servers will never rarely get + * to reboot, since Linux is so robust these days. :-) + * + * 180 days (six months) seems like a good 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; +#ifdef EXT2_DFL_CHECKINTERVAL +#undef EXT2_DFL_CHECKINTERVAL +#endif +#define EXT2_DFL_CHECKINTERVAL (86400L * 180L) + + if (get_bool_from_profile(fs_types, "enable_periodic_fsck", 0)) { + fs->super->s_checkinterval = EXT2_DFL_CHECKINTERVAL; + fs->super->s_max_mnt_count = EXT2_DFL_MAX_MNT_COUNT; + /* + * 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; + } else + fs->super->s_max_mnt_count = -1; /* * Override the creator OS, if applicable @@ -2028,15 +2427,34 @@ int main (int argc, char *argv[]) } if (!quiet) printf(_("done \n")); + + retval = ext2fs_convert_subcluster_bitmap(fs, &fs->block_map); + if (retval) { + com_err(program_name, retval, + _("\n\twhile converting subcluster bitmap")); + exit(1); + } + if (super_only) { fs->super->s_state |= EXT2_ERROR_FS; fs->flags &= ~(EXT2_FLAG_IB_DIRTY|EXT2_FLAG_BB_DIRTY); + /* + * The command "mke2fs -S" is used to recover + * corrupted file systems, so do not mark any of the + * inodes as unused; we want e2fsck to consider all + * inodes as potentially containing recoverable data. + */ + if (fs->super->s_feature_ro_compat & + EXT4_FEATURE_RO_COMPAT_GDT_CSUM) { + for (i = 0; i < fs->group_desc_count; i++) + ext2fs_bg_itable_unused_set(fs, i, 0); + } } else { /* rsv must be a power of two (64kB is MD RAID sb alignment) */ - unsigned int rsv = 65536 / fs->blocksize; - unsigned long blocks = ext2fs_blocks_count(fs->super); - unsigned long start; - blk_t ret_blk; + blk64_t rsv = 65536 / fs->blocksize; + blk64_t blocks = ext2fs_blocks_count(fs->super); + blk64_t start; + blk64_t ret_blk; #ifdef ZAP_BOOTBLOCK zap_sector(fs, 0, 2); @@ -2051,15 +2469,15 @@ int main (int argc, char *argv[]) if (start > rsv) start -= rsv; if (start > 0) - retval = ext2fs_zero_blocks(fs, start, blocks - start, + retval = ext2fs_zero_blocks2(fs, start, blocks - start, &ret_blk, NULL); if (retval) { com_err(program_name, retval, - _("while zeroing block %u at end of filesystem"), + _("while zeroing block %llu at end of filesystem"), ret_blk); } - write_inode_tables(fs, lazy_itable_init); + write_inode_tables(fs, lazy_itable_init, itable_zeroed); create_root_dir(fs); create_lost_and_found(fs); reserve_inodes(fs); @@ -2139,23 +2557,47 @@ int main (int argc, char *argv[]) printf(_("done\n")); } no_journal: + if (!super_only && + fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_MMP) { + retval = ext2fs_mmp_init(fs); + if (retval) { + fprintf(stderr, _("\nError while enabling multiple " + "mount protection feature.")); + exit(1); + } + if (!quiet) + printf(_("Multiple mount protection is enabled " + "with update interval %d seconds.\n"), + fs->super->s_mmp_update_interval); + } + + if (EXT2_HAS_RO_COMPAT_FEATURE(&fs_param, + EXT4_FEATURE_RO_COMPAT_BIGALLOC)) + fix_cluster_bg_counts(fs); + if (EXT2_HAS_RO_COMPAT_FEATURE(&fs_param, + EXT4_FEATURE_RO_COMPAT_QUOTA)) + create_quota_inodes(fs); if (!quiet) printf(_("Writing superblocks and " "filesystem accounting information: ")); - retval = ext2fs_flush(fs); + checkinterval = fs->super->s_checkinterval; + max_mnt_count = fs->super->s_max_mnt_count; + retval = ext2fs_close(fs); if (retval) { fprintf(stderr, _("\nWarning, had trouble writing out superblocks.")); - } - if (!quiet) { + } else if (!quiet) { printf(_("done\n\n")); if (!getenv("MKE2FS_SKIP_CHECK_MSG")) - print_check_message(fs); + print_check_message(max_mnt_count, checkinterval); } - val = ext2fs_close(fs); + remove_error_table(&et_ext2_error_table); remove_error_table(&et_prof_error_table); profile_release(profile); - return (retval || val) ? 1 : 0; + for (i=0; fs_types[i]; i++) + free(fs_types[i]); + free(fs_types); + return retval; }