* enforced (but it's not much fun on a character device :-).
*/
-#define _XOPEN_SOURCE 600 /* for inclusion of PATH_MAX */
+#define _XOPEN_SOURCE 600
#include "config.h"
#include <stdio.h>
int journal_flags;
static int lazy_itable_init;
static int packed_meta_blocks;
+int no_copy_xattrs;
static char *bad_blocks_filename = NULL;
static __u32 fs_stride;
/* Initialize usr/grp quotas by default */
static char *undo_file;
static int android_sparse_file; /* -E android_sparse */
-static char *android_sparse_params;
static profile_t profile;
exit(1);
}
- for (ino = 1; ino < EXT2_FIRST_INO(fs->super); ino++)
- ext2fs_write_inode_full(fs, ino, inode,
- EXT2_INODE_SIZE(fs->super));
+ for (ino = 1; ino < EXT2_FIRST_INO(fs->super); ino++) {
+ retval = ext2fs_write_inode_full(fs, ino, inode,
+ EXT2_INODE_SIZE(fs->super));
+ if (retval) {
+ com_err("ext2fs_write_inode_full", retval,
+ _("while writing reserved inodes"));
+ exit(1);
+ }
+ }
ext2fs_free_mem(&inode);
}
}
if (sync_kludge) {
if (sync_kludge == 1)
- sync();
+ io_channel_flush(fs->io);
else if ((i % sync_kludge) == 0)
- sync();
+ io_channel_flush(fs->io);
}
}
ext2fs_numeric_progress_close(fs, &progress,
int len;
int r_usage = 0;
int ret;
+ int encoding = -1;
+ char *encoding_flags = NULL;
len = strlen(opts);
buf = malloc(len+1);
r_usage++;
continue;
}
+ } else if (strcmp(token, "no_copy_xattrs") == 0) {
+ no_copy_xattrs = 1;
+ continue;
} else if (strcmp(token, "num_backup_sb") == 0) {
if (!arg) {
r_usage++;
}
} else if (!strcmp(token, "android_sparse")) {
android_sparse_file = 1;
+ } else if (!strcmp(token, "encoding")) {
+ if (!arg) {
+ r_usage++;
+ continue;
+ }
+
+ encoding = e2p_str2encoding(arg);
+ if (encoding < 0) {
+ fprintf(stderr, _("Invalid encoding: %s"), arg);
+ r_usage++;
+ continue;
+ }
+ param->s_encoding = encoding;
+ ext2fs_set_feature_casefold(param);
+ } else if (!strcmp(token, "encoding_flags")) {
+ if (!arg) {
+ r_usage++;
+ continue;
+ }
+ encoding_flags = arg;
} else {
r_usage++;
badopt = token;
"\ttest_fs\n"
"\tdiscard\n"
"\tnodiscard\n"
+ "\tencoding=<encoding>\n"
+ "\tencoding_flags=<flags>\n"
"\tquotatype=<quota type(s) to be enabled>\n\n"),
badopt ? badopt : "");
free(buf);
"multiple of stride %u.\n\n"),
param->s_raid_stripe_width, param->s_raid_stride);
+ if (ext2fs_has_feature_casefold(param)) {
+ param->s_encoding_flags =
+ e2p_get_encoding_flags(param->s_encoding);
+
+ if (encoding_flags &&
+ e2p_str2encoding_flags(param->s_encoding, encoding_flags,
+ ¶m->s_encoding_flags)) {
+ fprintf(stderr, _("error: Invalid encoding flag: %s\n"),
+ encoding_flags);
+ free(buf);
+ exit(1);
+ }
+ } else if (encoding_flags) {
+ fprintf(stderr, _("error: An encoding must be explicitly "
+ "specified when passing encoding-flags\n"));
+ free(buf);
+ exit(1);
+ }
+
free(buf);
}
EXT4_FEATURE_INCOMPAT_64BIT|
EXT4_FEATURE_INCOMPAT_INLINE_DATA|
EXT4_FEATURE_INCOMPAT_ENCRYPT |
+ EXT4_FEATURE_INCOMPAT_CASEFOLD |
EXT4_FEATURE_INCOMPAT_CSUM_SEED |
EXT4_FEATURE_INCOMPAT_LARGEDIR,
/* R/O compat */
EXT4_FEATURE_RO_COMPAT_BIGALLOC|
EXT4_FEATURE_RO_COMPAT_QUOTA|
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM|
- EXT4_FEATURE_RO_COMPAT_PROJECT
+ EXT4_FEATURE_RO_COMPAT_PROJECT|
+ EXT4_FEATURE_RO_COMPAT_VERITY
};
}
putenv (newpath);
- 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))
if (optind < argc)
usage();
+ profile_get_integer(profile, "options", "sync_kludge", 0, 0,
+ &sync_kludge);
+ tmp = getenv("MKE2FS_SYNC");
+ if (tmp)
+ sync_kludge = atoi(tmp);
+
profile_get_integer(profile, "options", "proceed_delay", 0, 0,
&proceed_delay);
ext2fs_clear_feature_huge_file(&fs_param);
ext2fs_clear_feature_metadata_csum(&fs_param);
ext2fs_clear_feature_ea_inode(&fs_param);
+ ext2fs_clear_feature_casefold(&fs_param);
}
edit_feature(fs_features ? fs_features : tmp,
&fs_param.s_feature_compat);
}
/*
* Guard against group descriptor count overflowing... Mostly to avoid
- * strange results for absurdly large devices.
+ * strange results for absurdly large devices. This is in log2:
+ * (blocksize) * (bits per byte) * (maximum number of block groups)
*/
- if (fs_blocks_count > ((1ULL << (fs_param.s_log_block_size + 3 + 32)) - 1)) {
+ if (fs_blocks_count >
+ (1ULL << (EXT2_BLOCK_SIZE_BITS(&fs_param) + 3 + 32)) - 1) {
fprintf(stderr, _("%s: Size of device (0x%llx blocks) %s "
"too big to create\n\t"
"a filesystem using a blocksize of %d.\n"),
if (packed_meta_blocks)
journal_location = 0;
+ if (ext2fs_has_feature_casefold(&fs_param)) {
+ char *ef, *en = get_string_from_profile(fs_types,
+ "encoding", "utf8");
+ int encoding = e2p_str2encoding(en);
+
+ if (encoding < 0) {
+ com_err(program_name, 0,
+ _("Unknown filename encoding from profile: %s"),
+ en);
+ exit(1);
+ }
+ free(en);
+ fs_param.s_encoding = encoding;
+ ef = get_string_from_profile(fs_types, "encoding_flags", NULL);
+ if (ef) {
+ if (e2p_str2encoding_flags(encoding, ef,
+ &fs_param.s_encoding_flags) < 0) {
+ com_err(program_name, 0,
+ _("Unknown encoding flags from profile: %s"), ef);
+ exit(1);
+ }
+ free(ef);
+ } else
+ fs_param.s_encoding_flags =
+ e2p_get_encoding_flags(encoding);
+ }
+
/* Get options from profile */
for (cpp = fs_types; *cpp; cpp++) {
tmp = NULL;
}
}
+ if (ext2fs_has_feature_casefold(&fs_param) &&
+ ext2fs_has_feature_encrypt(&fs_param)) {
+ com_err(program_name, 0, "%s",
+ _("The encrypt and casefold features are not "
+ "compatible.\nThey can not be both enabled "
+ "simultaneously.\n"));
+ exit (1);
+ }
+
/* Don't allow user to set both metadata_csum and uninit_bg bits. */
if (ext2fs_has_feature_metadata_csum(&fs_param) &&
ext2fs_has_feature_gdt_csum(&fs_param))
if (!quiet)
flags |= EXT2_FLAG_PRINT_PROGRESS;
if (android_sparse_file) {
- android_sparse_params = malloc(PATH_MAX + 32);
+ char *android_sparse_params = malloc(strlen(device_name) + 48);
+
if (!android_sparse_params) {
com_err(program_name, ENOMEM, "%s",
_("in malloc for android_sparse_params"));
exit(1);
}
- snprintf(android_sparse_params, PATH_MAX + 32, "(%s):%u:%u",
+ sprintf(android_sparse_params, "(%s):%u:%u",
device_name, fs_param.s_blocks_count,
1024 << fs_param.s_log_block_size);
retval = ext2fs_initialize(android_sparse_params, flags,
&fs_param, sparse_io_manager, &fs);
+ free(android_sparse_params);
} else
retval = ext2fs_initialize(device_name, flags, &fs_param,
io_ptr, &fs);
max_mnt_count = fs->super->s_max_mnt_count;
retval = ext2fs_close_free(&fs);
if (retval) {
- fprintf(stderr, "%s",
- _("\nWarning, had trouble writing out superblocks.\n"));
+ com_err(program_name, retval, "%s",
+ _("while writing out and closing file system"));
+ retval = 1;
} else if (!quiet) {
printf("%s", _("done\n\n"));
if (!getenv("MKE2FS_SKIP_CHECK_MSG"))
git://git.whamcloud.com / tools / e2fsprogs.git / blobdiff