sprintf(buf, "badblocks -b %d -X %s%s%s %llu", fs->blocksize,
quiet ? "" : "-s ", (cflag > 1) ? "-w " : "",
- fs->device_name, ext2fs_blocks_count(fs->super)-1);
+ fs->device_name,
+ (unsigned long long) ext2fs_blocks_count(fs->super)-1);
if (verbose)
printf(_("Running command: %s\n"), buf);
f = popen(buf, "r");
if (retval) {
fprintf(stderr, _("\nCould not write %d "
"blocks in inode table starting at %llu: %s\n"),
- num, blk, error_message(retval));
+ num, (unsigned long long) blk,
+ error_message(retval));
exit(1);
}
}
else {
magic = (unsigned int *) (buf + BSD_LABEL_OFFSET);
if ((*magic == BSD_DISKMAGIC) ||
- (*magic == BSD_MAGICDISK))
+ (*magic == BSD_MAGICDISK)) {
+ free(buf);
return;
+ }
}
}
com_err("create_journal_dev", retval,
_("while zeroing journal device "
"(block %llu, count %d)"),
- err_blk, err_count);
+ (unsigned long long) err_blk, err_count);
exit(1);
}
blk += c;
if (!verbose) {
printf(_("Creating filesystem with %llu %dk blocks and "
"%u inodes\n"),
- ext2fs_blocks_count(s), fs->blocksize >> 10,
- s->s_inodes_count);
+ (unsigned long long) ext2fs_blocks_count(s),
+ fs->blocksize >> 10, s->s_inodes_count);
goto skip_details;
}
if (ext2fs_blocks_count(&fs_param) != ext2fs_blocks_count(s))
fprintf(stderr, _("warning: %llu blocks unused.\n\n"),
- ext2fs_blocks_count(&fs_param) - ext2fs_blocks_count(s));
+ (unsigned long long) (ext2fs_blocks_count(&fs_param) -
+ ext2fs_blocks_count(s)));
printf(_("Filesystem label=%.*s\n"), EXT2_LEN_STR(s->s_volume_name));
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,
- ext2fs_blocks_count(s));
+ (unsigned long long) ext2fs_blocks_count(s));
printf(_("%llu blocks (%2.2f%%) reserved for the super user\n"),
- ext2fs_r_blocks_count(s),
+ (unsigned long long) ext2fs_r_blocks_count(s),
100.0 * ext2fs_r_blocks_count(s) / ext2fs_blocks_count(s));
printf(_("First data block=%u\n"), s->s_first_data_block);
if (root_uid != 0 || root_gid != 0)
col_left = 72;
}
col_left -= need;
- printf("%llu", group_block);
+ printf("%llu", (unsigned long long) group_block);
}
printf("\n\n");
}
static const char *default_files[] = { "<default>", 0 };
struct device_param {
- unsigned long min_io; /* prefered minimum IO size */
+ unsigned long min_io; /* preferred minimum IO size */
unsigned long opt_io; /* optimal IO size */
unsigned long alignment_offset; /* alignment offset wrt physical block size */
unsigned int dax:1; /* supports dax? */
* Finally, we complain about fs_blocks_count > 2^32 on a non-64bit fs.
*/
blk64_t fs_blocks_count = 0;
- long sysval;
int s_opt = -1, r_opt = -1;
char *fs_features = 0;
int fs_features_size = 0;
int use_bsize;
char *newpath;
int pathlen = sizeof(PATH_SET) + 1;
+#ifdef HAVE_BLKID_PROBE_GET_TOPOLOGY
struct device_param dev_param;
+#endif
if (oldpath)
pathlen += strlen(oldpath);
#define _SC_PAGESIZE _SC_PAGE_SIZE
#endif
#ifdef _SC_PAGESIZE
- sysval = sysconf(_SC_PAGESIZE);
- if (sysval > 0)
- sys_page_size = sysval;
+ {
+ long sysval = sysconf(_SC_PAGESIZE);
+
+ if (sysval > 0)
+ sys_page_size = sysval;
+ }
#endif /* _SC_PAGESIZE */
#endif /* HAVE_SYSCONF */
#ifdef CONFIG_TESTIO_DEBUG
if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_BLOCK")) {
io_ptr = test_io_manager;
- test_io_backing_manager = unix_io_manager;
+ test_io_backing_manager = default_io_manager;
} else
#endif
- io_ptr = unix_io_manager;
+ io_ptr = default_io_manager;
retval = ext2fs_open(journal_device,
EXT2_FLAG_JOURNAL_DEV_OK, 0,
0, io_ptr, &jfs);
profile_get_integer(profile, "options", "proceed_delay", 0, 0,
&proceed_delay);
- /* The isatty() test is so we don't break existing scripts */
- flags = CREATE_FILE;
- if (isatty(0) && isatty(1) && !offset)
- flags |= CHECK_FS_EXIST;
- if (!quiet)
- flags |= VERBOSE_CREATE;
- if (fs_blocks_count == 0)
- flags |= NO_SIZE;
- else
+ if (fs_blocks_count)
explicit_fssize = 1;
- if (!check_plausibility(device_name, flags, &is_device) && !force)
- proceed_question(proceed_delay);
check_mount(device_name, force, _("filesystem"));
dev_size = fs_blocks_count;
retval = 0;
} else
-#ifndef _WIN32
retval = ext2fs_get_device_size2(device_name,
EXT2_BLOCK_SIZE(&fs_param),
&dev_size);
-#else
- retval = ext2fs_get_device_size(device_name,
- EXT2_BLOCK_SIZE(&fs_param),
- &dev_size);
-#endif
+ if (retval == ENOENT) {
+ int fd;
+
+ if (!explicit_fssize) {
+ fprintf(stderr,
+ _("The file %s does not exist and no "
+ "size was specified.\n"), device_name);
+ exit(1);
+ }
+ fd = ext2fs_open_file(device_name,
+ O_CREAT | O_WRONLY, 0666);
+ if (fd < 0) {
+ retval = errno;
+ } else {
+ dev_size = 0;
+ retval = 0;
+ close(fd);
+ printf(_("Creating regular file %s\n"), device_name);
+ }
+ }
if (retval && (retval != EXT2_ET_UNIMPLEMENTED)) {
com_err(program_name, retval, "%s",
_("while trying to determine filesystem size"));
if (!usage_types)
profile_get_string(profile, "devices", device_name,
"usage_types", 0, &usage_types);
+ if (!creator_os)
+ profile_get_string(profile, "defaults", "creator_os", 0,
+ 0, &creator_os);
/*
* We have the file system (or device) size, so we can now
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));
+ program_name, (unsigned long long) fs_blocks_count,
+ device_name, EXT2_BLOCK_SIZE(&fs_param));
exit(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"),
- program_name, fs_blocks_count, device_name,
- EXT2_BLOCK_SIZE(&fs_param));
+ program_name, (unsigned long long) fs_blocks_count,
+ device_name, EXT2_BLOCK_SIZE(&fs_param));
exit(1);
}
device_name);
} else {
/* setting stripe/stride to blocksize is pointless */
- if (dev_param.min_io > blocksize)
+ if (dev_param.min_io > (unsigned) blocksize)
fs_param.s_raid_stride = dev_param.min_io / blocksize;
- if (dev_param.opt_io > blocksize) {
+ if (dev_param.opt_io > (unsigned) blocksize) {
fs_param.s_raid_stripe_width =
dev_param.opt_io / blocksize;
}
}
}
- 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))
exit(1);
}
- if (!quiet && ext2fs_has_feature_bigalloc(&fs_param))
- fprintf(stderr, "%s", _("\nWarning: the bigalloc feature is "
- "still under development\n"
- "See https://ext4.wiki.kernel.org/"
- "index.php/Bigalloc for more information\n\n"));
+ if (!quiet && ext2fs_has_feature_bigalloc(&fs_param) &&
+ EXT2_CLUSTER_SIZE(&fs_param) > 16 * EXT2_BLOCK_SIZE(&fs_param))
+ fprintf(stderr, "%s", _("\nWarning: bigalloc file systems "
+ "with a cluster size greater than\n"
+ "16 times the block size is considered "
+ "experimental\n"));
/*
* Since sparse_super is the default, we would only have a problem
exit(1);
}
+ /*
+ * Warn the user that filesystems with 128-byte inodes will
+ * not work properly beyond 2038. This can be suppressed via
+ * a boolean in the mke2fs.conf file, and we will disable this
+ * warning for file systems created for the GNU Hurd.
+ */
+ if (inode_size == EXT2_GOOD_OLD_INODE_SIZE &&
+ get_bool_from_profile(fs_types, "warn_y2038_dates", 1))
+ printf(
+_("128-byte inodes cannot handle dates beyond 2038 and are deprecated\n"));
+
/* Make sure number of inodes specified will fit in 32 bits */
if (num_inodes == 0) {
unsigned long long n;
else {
com_err(program_name, 0,
_("too many inodes (%llu), raise "
- "inode ratio?"), n);
+ "inode ratio?"),
+ (unsigned long long) n);
exit(1);
}
}
} else if (num_inodes > MAX_32_NUM) {
com_err(program_name, 0,
_("too many inodes (%llu), specify < 2^32 inodes"),
- num_inodes);
+ (unsigned long long) num_inodes);
exit(1);
}
/*
free(fs_type);
free(usage_types);
+
+ /* The isatty() test is so we don't break existing scripts */
+ flags = CREATE_FILE;
+ if (isatty(0) && isatty(1) && !offset)
+ flags |= CHECK_FS_EXIST;
+ if (!quiet)
+ flags |= VERBOSE_CREATE;
+ if (!explicit_fssize)
+ flags |= NO_SIZE;
+ if (!check_plausibility(device_name, flags, &is_device) && !force)
+ proceed_question(proceed_delay);
}
static int should_do_undo(const char *name)
io_channel channel;
__u16 s_magic;
struct ext2_super_block super;
- io_manager manager = unix_io_manager;
+ io_manager manager = default_io_manager;
int csum_flag, force_undo;
csum_flag = ext2fs_has_feature_metadata_csum(&fs_param) ||
struct ext2fs_numeric_progress_struct progress;
blk64_t blocks = ext2fs_blocks_count(fs->super);
blk64_t count = DISCARD_STEP_MB;
- blk64_t cur;
+ blk64_t cur = 0;
int retval = 0;
/*
* we do not print numeric progress resulting in failure
* afterwards.
*/
- retval = io_channel_discard(fs->io, 0, fs->blocksize);
+ retval = io_channel_discard(fs->io, 0, 1);
if (retval)
return retval;
- cur = fs->blocksize;
count *= (1024 * 1024);
count /= fs->blocksize;
#ifdef CONFIG_TESTIO_DEBUG
if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_BLOCK")) {
io_ptr = test_io_manager;
- test_io_backing_manager = unix_io_manager;
+ test_io_backing_manager = default_io_manager;
} else
#endif
- io_ptr = unix_io_manager;
+ io_ptr = default_io_manager;
if (undo_file != NULL || should_do_undo(device_name)) {
retval = mke2fs_setup_tdb(device_name, &io_ptr);
32768 : fs->blocksize * 8);
io_channel_set_options(fs->io, opt_string);
if (offset) {
- sprintf(opt_string, "offset=%llu", offset);
+ sprintf(opt_string, "offset=%llu", (unsigned long long) offset);
io_channel_set_options(fs->io, opt_string);
}
if (volume_label) {
memset(fs->super->s_volume_name, 0,
sizeof(fs->super->s_volume_name));
- strncpy(fs->super->s_volume_name, volume_label,
+ strncpy((char *) fs->super->s_volume_name, volume_label,
sizeof(fs->super->s_volume_name));
}
if (mount_dir) {
memset(fs->super->s_last_mounted, 0,
sizeof(fs->super->s_last_mounted));
- strncpy(fs->super->s_last_mounted, mount_dir,
+ strncpy((char *) fs->super->s_last_mounted, mount_dir,
sizeof(fs->super->s_last_mounted));
}
if (retval) {
com_err(program_name, retval,
_("while zeroing block %llu at end of filesystem"),
- ret_blk);
+ (unsigned long long) ret_blk);
}
write_inode_tables(fs, lazy_itable_init, itable_zeroed);
create_root_dir(fs);
retval = ext2fs_open(journal_device, EXT2_FLAG_RW|
EXT2_FLAG_JOURNAL_DEV_OK, 0,
- fs->blocksize, unix_io_manager, &jfs);
+ fs->blocksize, default_io_manager, &jfs);
if (retval) {
com_err(program_name, retval,
_("while trying to open journal device %s\n"),
git://git.whamcloud.com / tools / e2fsprogs.git / blobdiff