1997-04-26 17:21:57 +04:00
|
|
|
/*
|
|
|
|
* mke2fs.c - Make a ext2fs filesystem.
|
2008-08-28 07:07:54 +04:00
|
|
|
*
|
2005-01-05 11:01:06 +03:00
|
|
|
* Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
|
|
|
|
* 2003, 2004, 2005 by Theodore Ts'o.
|
1997-04-29 20:17:09 +04:00
|
|
|
*
|
|
|
|
* %Begin-Header%
|
|
|
|
* This file may be redistributed under the terms of the GNU Public
|
|
|
|
* License.
|
|
|
|
* %End-Header%
|
1997-04-26 17:21:57 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
/* Usage: mke2fs [options] device
|
2008-08-28 07:07:54 +04:00
|
|
|
*
|
1997-04-26 17:21:57 +04:00
|
|
|
* The device may be a block device or a image of one, but this isn't
|
2008-08-28 07:07:54 +04:00
|
|
|
* enforced (but it's not much fun on a character device :-).
|
1997-04-26 17:21:57 +04:00
|
|
|
*/
|
|
|
|
|
2008-07-13 23:32:37 +04:00
|
|
|
#define _XOPEN_SOURCE 600 /* for inclusion of PATH_MAX in Solaris */
|
|
|
|
|
2011-09-19 01:34:37 +04:00
|
|
|
#include "config.h"
|
1997-04-26 18:00:26 +04:00
|
|
|
#include <stdio.h>
|
1997-04-26 17:21:57 +04:00
|
|
|
#include <string.h>
|
2009-07-19 02:41:51 +04:00
|
|
|
#include <strings.h>
|
1997-04-26 17:21:57 +04:00
|
|
|
#include <fcntl.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <time.h>
|
2002-03-08 04:52:12 +03:00
|
|
|
#ifdef __linux__
|
1999-09-15 00:11:19 +04:00
|
|
|
#include <sys/utsname.h>
|
2014-02-07 00:24:01 +04:00
|
|
|
#include <linux/version.h>
|
1999-09-15 00:11:19 +04:00
|
|
|
#endif
|
1997-04-26 18:00:26 +04:00
|
|
|
#ifdef HAVE_GETOPT_H
|
1997-04-26 17:21:57 +04:00
|
|
|
#include <getopt.h>
|
Many files:
badblocks.c, dumpe2fs.c, e2label.c, mke2fs.c, tune2fs.c, uuidgen.c:
For platforms that don't define optarg.h, manually define optarg and
optind.
ChangeLog, main.c:
main.c: For platforms that don't define optarg.h, manually define
optarg and optind.
ChangeLog, unix.c:
unix.c: For platforms that don't define optarg.h, manually define
optarg and optind.
2000-04-03 20:22:35 +04:00
|
|
|
#else
|
|
|
|
extern char *optarg;
|
|
|
|
extern int optind;
|
1997-04-26 18:00:26 +04:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_UNISTD_H
|
1997-04-26 17:21:57 +04:00
|
|
|
#include <unistd.h>
|
1997-04-26 18:00:26 +04:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_STDLIB_H
|
1997-04-26 17:21:57 +04:00
|
|
|
#include <stdlib.h>
|
1997-04-26 18:00:26 +04:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ERRNO_H
|
|
|
|
#include <errno.h>
|
|
|
|
#endif
|
1997-04-26 17:21:57 +04:00
|
|
|
#include <sys/ioctl.h>
|
1997-04-26 17:34:30 +04:00
|
|
|
#include <sys/types.h>
|
2010-01-24 06:50:45 +03:00
|
|
|
#include <sys/stat.h>
|
2007-08-13 14:26:26 +04:00
|
|
|
#include <libgen.h>
|
2008-06-08 06:07:50 +04:00
|
|
|
#include <limits.h>
|
2009-10-02 20:32:42 +04:00
|
|
|
#include <blkid/blkid.h>
|
1997-04-26 17:34:30 +04:00
|
|
|
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2image.c, findsuper.c, lsattr.c,
mke2fs.c, mklost+found.c, tune2fs.c, util.c: Change location of
ext2_fs.h to be ext2fs/ext2_fs.h
ChangeLog, Makefile.in, resize2fs.h:
resize2fs.h: Change location of ext2_fs.h to be ext2fs/ext2_fs.h
ChangeLog, Makefile.in, debugfs.h:
debugfs.h: Change location of ext2_fs.h to be ext2fs/ext2_fs.h
ChangeLog, Makefile.in, e2fsck.h, scantest.c:
e2fsck.h, scantest.c: Change location of ext2_fs.h to be
ext2fs/ext2_fs.h
ChangeLog, Makefile.in, tst_uuid.c, uuid_time.c:
tst_uuid.c, uuid_time.c: Remove unneeded #include of ext2_fs.h
ChangeLog, Makefile.in, e2p.h:
e2p.h: Change location of ext2_fs.h to be ext2fs/ext2_fs.h
ChangeLog, Makefile.in, test_icount.c, test_rel.c:
test_icount.c, test_rel.c: Change location of ext2_fs.h to be
ext2fs/ext2_fs.h
2001-05-14 15:45:38 +04:00
|
|
|
#include "ext2fs/ext2_fs.h"
|
2009-08-24 03:20:03 +04:00
|
|
|
#include "ext2fs/ext2fsP.h"
|
1997-04-26 17:21:57 +04:00
|
|
|
#include "et/com_err.h"
|
1997-04-29 18:53:37 +04:00
|
|
|
#include "uuid/uuid.h"
|
1999-10-23 05:04:50 +04:00
|
|
|
#include "e2p/e2p.h"
|
1997-04-26 17:21:57 +04:00
|
|
|
#include "ext2fs/ext2fs.h"
|
ChangeLog, Makefile.in, mke2fs.c, tune2fs.8.in, tune2fs.c, util.c, util.h:
tune2fs.c (update_feature_set, add_journal): Moved to separate
functions. Added ability to add and remove the journal while the
filesystem is live. Added support for setting a time-based UUID.
Removed zero-initialized static variables.
mke2fs.c, util.c, util.h (strcasecmp, proceed_question,
check_plausibility, parse_journal_opts, check_mount): Moved functions
to util.c so they can be used by tune2fs.
mke2fs.c (main): Change ext2fs_add_journal_fs() to
ext2fs_add_journal_inode() to reflect function renaming.
2001-01-03 20:02:13 +03:00
|
|
|
#include "util.h"
|
2006-03-24 06:00:01 +03:00
|
|
|
#include "profile.h"
|
2006-12-26 11:38:07 +03:00
|
|
|
#include "prof_err.h"
|
1997-04-26 17:21:57 +04:00
|
|
|
#include "../version.h"
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
#include "nls-enable.h"
|
2014-05-11 02:55:20 +04:00
|
|
|
#include "quota/quotaio.h"
|
2014-01-21 08:06:07 +04:00
|
|
|
#include "mke2fs.h"
|
1997-04-26 17:21:57 +04:00
|
|
|
|
|
|
|
#define STRIDE_LENGTH 8
|
|
|
|
|
2010-06-13 22:00:00 +04:00
|
|
|
#define MAX_32_NUM ((((unsigned long long) 1) << 32) - 1)
|
|
|
|
|
1999-11-23 05:23:30 +03:00
|
|
|
#ifndef __sparc__
|
1997-04-29 18:53:37 +04:00
|
|
|
#define ZAP_BOOTBLOCK
|
|
|
|
#endif
|
|
|
|
|
2011-01-24 22:52:00 +03:00
|
|
|
#define DISCARD_STEP_MB (2048)
|
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
extern int isatty(int);
|
1997-04-26 17:34:30 +04:00
|
|
|
extern FILE *fpopen(const char *cmd, const char *mode);
|
1997-04-26 17:21:57 +04:00
|
|
|
|
2014-01-21 08:06:07 +04:00
|
|
|
const char * program_name = "mke2fs";
|
2013-12-17 03:56:36 +04:00
|
|
|
static const char * device_name /* = NULL */;
|
1997-04-26 17:21:57 +04:00
|
|
|
|
|
|
|
/* Command line options */
|
2013-12-17 03:56:36 +04:00
|
|
|
static int cflag;
|
2014-01-21 08:06:07 +04:00
|
|
|
int verbose;
|
|
|
|
int quiet;
|
2013-12-17 03:56:36 +04:00
|
|
|
static int super_only;
|
|
|
|
static int discard = 1; /* attempt to discard device before fs creation */
|
|
|
|
static int direct_io;
|
|
|
|
static int force;
|
|
|
|
static int noaction;
|
2014-01-12 07:11:42 +04:00
|
|
|
static int num_backups = 2; /* number of backup bg's for sparse_super2 */
|
2013-12-17 03:56:36 +04:00
|
|
|
static uid_t root_uid;
|
|
|
|
static gid_t root_gid;
|
2001-01-16 10:47:31 +03:00
|
|
|
int journal_size;
|
|
|
|
int journal_flags;
|
2013-12-17 03:56:36 +04:00
|
|
|
static int lazy_itable_init;
|
2014-01-28 23:44:23 +04:00
|
|
|
static int packed_meta_blocks;
|
2013-12-17 03:56:36 +04:00
|
|
|
static char *bad_blocks_filename = NULL;
|
|
|
|
static __u32 fs_stride;
|
|
|
|
static int quotatype = -1; /* Initialize both user and group quotas by default */
|
2013-12-31 08:03:09 +04:00
|
|
|
static __u64 offset;
|
2014-01-28 21:58:56 +04:00
|
|
|
static blk64_t journal_location = ~0LL;
|
2014-04-27 01:34:52 +04:00
|
|
|
static int proceed_delay = -1;
|
2014-05-05 07:40:58 +04:00
|
|
|
static blk64_t dev_size;
|
2013-12-17 03:56:36 +04:00
|
|
|
|
|
|
|
static struct ext2_super_block fs_param;
|
|
|
|
static char *fs_uuid = NULL;
|
|
|
|
static char *creator_os;
|
|
|
|
static char *volume_label;
|
|
|
|
static char *mount_dir;
|
2001-01-16 10:47:31 +03:00
|
|
|
char *journal_device;
|
2013-12-17 03:56:36 +04:00
|
|
|
static int sync_kludge; /* Set using the MKE2FS_SYNC env. option */
|
2014-01-21 08:06:07 +04:00
|
|
|
char **fs_types;
|
1997-04-26 17:21:57 +04:00
|
|
|
|
2013-12-17 03:56:36 +04:00
|
|
|
static profile_t profile;
|
2006-03-24 06:00:01 +03:00
|
|
|
|
2013-12-17 03:56:36 +04:00
|
|
|
static int sys_page_size = 4096;
|
2002-05-17 18:53:07 +04:00
|
|
|
|
ChangeLog, Makefile.in, mke2fs.c, tune2fs.8.in, tune2fs.c, util.c, util.h:
tune2fs.c (update_feature_set, add_journal): Moved to separate
functions. Added ability to add and remove the journal while the
filesystem is live. Added support for setting a time-based UUID.
Removed zero-initialized static variables.
mke2fs.c, util.c, util.h (strcasecmp, proceed_question,
check_plausibility, parse_journal_opts, check_mount): Moved functions
to util.c so they can be used by tune2fs.
mke2fs.c (main): Change ext2fs_add_journal_fs() to
ext2fs_add_journal_inode() to reflect function renaming.
2001-01-03 20:02:13 +03:00
|
|
|
static void usage(void)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
2008-02-29 05:12:31 +03:00
|
|
|
fprintf(stderr, _("Usage: %s [-c|-l filename] [-b block-size] "
|
2011-10-05 02:12:11 +04:00
|
|
|
"[-C cluster-size]\n\t[-i bytes-per-inode] [-I inode-size] "
|
2008-02-29 05:12:31 +03:00
|
|
|
"[-J journal-options]\n"
|
2012-01-23 20:46:43 +04:00
|
|
|
"\t[-G flex-group-size] [-N number-of-inodes]\n"
|
2008-04-22 16:27:01 +04:00
|
|
|
"\t[-m reserved-blocks-percentage] [-o creator-os]\n"
|
|
|
|
"\t[-g blocks-per-group] [-L volume-label] "
|
2006-07-16 06:08:20 +04:00
|
|
|
"[-M last-mounted-directory]\n\t[-O feature[,...]] "
|
2008-02-29 05:12:31 +03:00
|
|
|
"[-r fs-revision] [-E extended-option[,...]]\n"
|
2012-01-10 06:17:57 +04:00
|
|
|
"\t[-t fs-type] [-T usage-type ] [-U UUID] "
|
2012-03-23 00:00:49 +04:00
|
|
|
"[-jnqvDFKSV] device [blocks-count]\n"),
|
1997-04-26 17:21:57 +04:00
|
|
|
program_name);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2010-06-13 21:00:00 +04:00
|
|
|
static int int_log2(unsigned long long arg)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
|
|
|
int l = 0;
|
|
|
|
|
|
|
|
arg >>= 1;
|
|
|
|
while (arg) {
|
|
|
|
l++;
|
|
|
|
arg >>= 1;
|
|
|
|
}
|
|
|
|
return l;
|
|
|
|
}
|
|
|
|
|
2014-01-21 08:06:07 +04:00
|
|
|
int int_log10(unsigned long long arg)
|
ChangeLog, mke2fs.c, tune2fs.8.in:
tune2fs.8.in: Fix minor display bug in the nroff.
mke2fs.c (show_stats, write_inode_tables): Use the log10 function to
calculate the display of block numbers so that things look nice on an
80 character display.
mke2fs.c (usage): Add the sparse-super-flag to the usage message.
ChangeLog, e2fsck.c, pass1.c, pass2.c, problem.c, problem.h, unix.c:
unix.c (main): Move ext2fs_close() after e2fsck_free_context() since
e2fsck_free_context may reference data in ctx->fs.
e2fsck.c (e2fsck_reset_context): Make sure ctx->fs is non-NULL before
checking ctx->fs->dblist.
pass1.c (e2fsck_pass1): Use the device check subroutine on FIFO's and
Socket's, so that we catch bogus immutable inodes.
pass2.c (process_bad_inode): Process bad socket and fifo's.
problem.h, problem.c: Define new problem codes PR_2_BAD_FIFO and
PR_2_BAD_SOCKET.
1998-11-14 07:18:28 +03:00
|
|
|
{
|
|
|
|
int l;
|
|
|
|
|
|
|
|
for (l=0; arg ; l++)
|
|
|
|
arg = arg / 10;
|
|
|
|
return l;
|
|
|
|
}
|
|
|
|
|
2012-11-29 16:47:52 +04:00
|
|
|
#ifdef __linux__
|
2004-09-25 15:40:12 +04:00
|
|
|
static int parse_version_number(const char *s)
|
|
|
|
{
|
|
|
|
int major, minor, rev;
|
|
|
|
char *endptr;
|
|
|
|
const char *cp = s;
|
|
|
|
|
|
|
|
if (!s)
|
|
|
|
return 0;
|
|
|
|
major = strtol(cp, &endptr, 10);
|
|
|
|
if (cp == endptr || *endptr != '.')
|
|
|
|
return 0;
|
|
|
|
cp = endptr + 1;
|
|
|
|
minor = strtol(cp, &endptr, 10);
|
|
|
|
if (cp == endptr || *endptr != '.')
|
|
|
|
return 0;
|
|
|
|
cp = endptr + 1;
|
|
|
|
rev = strtol(cp, &endptr, 10);
|
|
|
|
if (cp == endptr)
|
|
|
|
return 0;
|
2014-02-07 00:24:01 +04:00
|
|
|
return KERNEL_VERSION(major, minor, rev);
|
|
|
|
}
|
|
|
|
|
2014-07-06 05:07:55 +04:00
|
|
|
static int is_before_linux_ver(unsigned int major, unsigned int minor,
|
|
|
|
unsigned int rev)
|
2014-02-07 00:24:01 +04:00
|
|
|
{
|
|
|
|
struct utsname ut;
|
|
|
|
static int linux_version_code = -1;
|
|
|
|
|
|
|
|
if (uname(&ut)) {
|
|
|
|
perror("uname");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
if (linux_version_code < 0)
|
|
|
|
linux_version_code = parse_version_number(ut.release);
|
|
|
|
if (linux_version_code == 0)
|
|
|
|
return 0;
|
|
|
|
|
2014-07-06 05:07:55 +04:00
|
|
|
return linux_version_code < KERNEL_VERSION(major, minor, rev);
|
2014-02-07 00:24:01 +04:00
|
|
|
}
|
|
|
|
#else
|
2014-07-06 05:07:55 +04:00
|
|
|
static int is_before_linux_ver(unsigned int major, unsigned int minor,
|
|
|
|
unsigned int rev)
|
2014-02-07 00:24:01 +04:00
|
|
|
{
|
|
|
|
return 0;
|
2004-09-25 15:40:12 +04:00
|
|
|
}
|
2012-11-29 16:47:52 +04:00
|
|
|
#endif
|
2004-09-25 15:40:12 +04:00
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
/*
|
|
|
|
* Helper function for read_bb_file and test_disk
|
|
|
|
*/
|
2003-12-07 09:28:50 +03:00
|
|
|
static void invalid_block(ext2_filsys fs EXT2FS_ATTR((unused)), blk_t blk)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
2002-03-08 08:14:46 +03:00
|
|
|
fprintf(stderr, _("Bad block %u out of range; ignored.\n"), blk);
|
1997-04-26 17:21:57 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reads the bad blocks list from a file
|
|
|
|
*/
|
|
|
|
static void read_bb_file(ext2_filsys fs, badblocks_list *bb_list,
|
|
|
|
const char *bad_blocks_file)
|
|
|
|
{
|
|
|
|
FILE *f;
|
|
|
|
errcode_t retval;
|
|
|
|
|
|
|
|
f = fopen(bad_blocks_file, "r");
|
|
|
|
if (!f) {
|
|
|
|
com_err("read_bad_blocks_file", errno,
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
_("while trying to open %s"), bad_blocks_file);
|
1997-04-26 17:21:57 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
retval = ext2fs_read_bb_FILE(fs, f, bb_list, invalid_block);
|
|
|
|
fclose (f);
|
|
|
|
if (retval) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err("ext2fs_read_bb_FILE", retval, "%s",
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
_("while reading in list of bad blocks from file"));
|
1997-04-26 17:21:57 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Runs the badblocks program to test the disk
|
|
|
|
*/
|
|
|
|
static void test_disk(ext2_filsys fs, badblocks_list *bb_list)
|
|
|
|
{
|
|
|
|
FILE *f;
|
|
|
|
errcode_t retval;
|
|
|
|
char buf[1024];
|
|
|
|
|
2009-09-08 04:46:34 +04:00
|
|
|
sprintf(buf, "badblocks -b %d -X %s%s%s %llu", fs->blocksize,
|
2001-12-24 23:01:59 +03:00
|
|
|
quiet ? "" : "-s ", (cflag > 1) ? "-w " : "",
|
2009-09-08 04:46:34 +04:00
|
|
|
fs->device_name, ext2fs_blocks_count(fs->super)-1);
|
1997-04-26 17:21:57 +04:00
|
|
|
if (verbose)
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
printf(_("Running command: %s\n"), buf);
|
1997-04-26 17:21:57 +04:00
|
|
|
f = popen(buf, "r");
|
|
|
|
if (!f) {
|
|
|
|
com_err("popen", errno,
|
2005-05-06 07:15:55 +04:00
|
|
|
_("while trying to run '%s'"), buf);
|
1997-04-26 17:21:57 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
retval = ext2fs_read_bb_FILE(fs, f, bb_list, invalid_block);
|
1997-04-26 17:34:30 +04:00
|
|
|
pclose(f);
|
1997-04-26 17:21:57 +04:00
|
|
|
if (retval) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err("ext2fs_read_bb_FILE", retval, "%s",
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
_("while processing list of bad blocks from program"));
|
1997-04-26 17:21:57 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void handle_bad_blocks(ext2_filsys fs, badblocks_list bb_list)
|
|
|
|
{
|
2003-12-07 09:28:50 +03:00
|
|
|
dgrp_t i;
|
|
|
|
blk_t j;
|
|
|
|
unsigned must_be_good;
|
1997-04-26 17:21:57 +04:00
|
|
|
blk_t blk;
|
|
|
|
badblocks_iterate bb_iter;
|
|
|
|
errcode_t retval;
|
1997-04-26 17:34:30 +04:00
|
|
|
blk_t group_block;
|
|
|
|
int group;
|
|
|
|
int group_bad;
|
1997-04-26 17:21:57 +04:00
|
|
|
|
|
|
|
if (!bb_list)
|
|
|
|
return;
|
2008-08-28 07:07:54 +04:00
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
/*
|
|
|
|
* The primary superblock and group descriptors *must* be
|
|
|
|
* good; if not, abort.
|
|
|
|
*/
|
|
|
|
must_be_good = fs->super->s_first_data_block + 1 + fs->desc_blocks;
|
|
|
|
for (i = fs->super->s_first_data_block; i <= must_be_good; i++) {
|
ChangeLog, dumpe2fs.c, mke2fs.c:
dumpe2fs.c: Use WORDS_BIGENDIAN to determine whether or not we're
(not) using i386 byte order.
dumpe2fs.c, mke2fs.c: Stop using the compatibility badblocks function,
and use the ext2fs_badblocks_* functions instead.
ChangeLog, inode.c, tst_iscan.c:
inode.c, tst_iscan.c: Stop using the compatibility badblocks function,
and use the ext2fs_badblocks_* functions instead.
ChangeLog, badblocks.c:
badblocks.c: Stop using the compatibility badblocks function, and use
the ext2fs_badblocks_* functions instead.
2001-06-13 04:12:04 +04:00
|
|
|
if (ext2fs_badblocks_list_test(bb_list, i)) {
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
fprintf(stderr, _("Block %d in primary "
|
|
|
|
"superblock/group descriptor area bad.\n"), i);
|
2006-09-12 22:56:15 +04:00
|
|
|
fprintf(stderr, _("Blocks %u through %u must be good "
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
"in order to build a filesystem.\n"),
|
1997-04-26 17:21:57 +04:00
|
|
|
fs->super->s_first_data_block, must_be_good);
|
2003-12-07 09:28:50 +03:00
|
|
|
fputs(_("Aborting....\n"), stderr);
|
1997-04-26 17:21:57 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
1997-04-26 17:34:30 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* See if any of the bad blocks are showing up in the backup
|
|
|
|
* superblocks and/or group descriptors. If so, issue a
|
|
|
|
* warning and adjust the block counts appropriately.
|
|
|
|
*/
|
|
|
|
group_block = fs->super->s_first_data_block +
|
|
|
|
fs->super->s_blocks_per_group;
|
2008-08-28 07:07:54 +04:00
|
|
|
|
1997-04-26 17:34:30 +04:00
|
|
|
for (i = 1; i < fs->group_desc_count; i++) {
|
1998-02-17 01:29:34 +03:00
|
|
|
group_bad = 0;
|
1997-04-26 17:34:30 +04:00
|
|
|
for (j=0; j < fs->desc_blocks+1; j++) {
|
ChangeLog, dumpe2fs.c, mke2fs.c:
dumpe2fs.c: Use WORDS_BIGENDIAN to determine whether or not we're
(not) using i386 byte order.
dumpe2fs.c, mke2fs.c: Stop using the compatibility badblocks function,
and use the ext2fs_badblocks_* functions instead.
ChangeLog, inode.c, tst_iscan.c:
inode.c, tst_iscan.c: Stop using the compatibility badblocks function,
and use the ext2fs_badblocks_* functions instead.
ChangeLog, badblocks.c:
badblocks.c: Stop using the compatibility badblocks function, and use
the ext2fs_badblocks_* functions instead.
2001-06-13 04:12:04 +04:00
|
|
|
if (ext2fs_badblocks_list_test(bb_list,
|
|
|
|
group_block + j)) {
|
2008-08-28 07:07:54 +04:00
|
|
|
if (!group_bad)
|
1997-04-26 17:34:30 +04:00
|
|
|
fprintf(stderr,
|
2006-03-19 05:43:46 +03:00
|
|
|
_("Warning: the backup superblock/group descriptors at block %u contain\n"
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
" bad blocks.\n\n"),
|
1997-04-26 17:34:30 +04:00
|
|
|
group_block);
|
|
|
|
group_bad++;
|
2009-10-26 03:50:15 +03:00
|
|
|
group = ext2fs_group_of_blk2(fs, group_block+j);
|
Convert to use block group accessor functions
Convert direct accesses to use the following block group accessor
functions: ext2fs_block_bitmap_loc(), ext2fs_inode_bitmap_loc(),
ext2fs_inode_table_loc(), ext2fs_bg_itable_unused(),
ext2fs_block_bitmap_loc_set(), ext2fs_inode_bitmap_loc_set(),
ext2fs_inode_table_loc_set(), ext2fs_bg_free_inodes_count(),
ext2fs_ext2fs_bg_used_dirs_count(), ext2fs_bg_free_inodes_count_set(),
ext2fs_bg_free_blocks_count_set(), ext2fs_bg_used_dirs_count_set()
Signed-off-by: Valerie Aurora Henson <vaurora@redhat.com>
Signed-off-by: Nick Dokos <nicholas.dokos@hp.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2009-10-26 04:43:47 +03:00
|
|
|
ext2fs_bg_free_blocks_count_set(fs, group, ext2fs_bg_free_blocks_count(fs, group) + 1);
|
2008-04-21 09:29:01 +04:00
|
|
|
ext2fs_group_desc_csum_set(fs, group);
|
2009-09-08 04:46:34 +04:00
|
|
|
ext2fs_free_blocks_count_add(fs->super, 1);
|
1997-04-26 17:34:30 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
group_block += fs->super->s_blocks_per_group;
|
|
|
|
}
|
2008-08-28 07:07:54 +04:00
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
/*
|
|
|
|
* Mark all the bad blocks as used...
|
|
|
|
*/
|
ChangeLog, dumpe2fs.c, mke2fs.c:
dumpe2fs.c: Use WORDS_BIGENDIAN to determine whether or not we're
(not) using i386 byte order.
dumpe2fs.c, mke2fs.c: Stop using the compatibility badblocks function,
and use the ext2fs_badblocks_* functions instead.
ChangeLog, inode.c, tst_iscan.c:
inode.c, tst_iscan.c: Stop using the compatibility badblocks function,
and use the ext2fs_badblocks_* functions instead.
ChangeLog, badblocks.c:
badblocks.c: Stop using the compatibility badblocks function, and use
the ext2fs_badblocks_* functions instead.
2001-06-13 04:12:04 +04:00
|
|
|
retval = ext2fs_badblocks_list_iterate_begin(bb_list, &bb_iter);
|
1997-04-26 17:21:57 +04:00
|
|
|
if (retval) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err("ext2fs_badblocks_list_iterate_begin", retval, "%s",
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
_("while marking bad blocks as used"));
|
1997-04-26 17:21:57 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
2008-08-28 07:07:54 +04:00
|
|
|
while (ext2fs_badblocks_list_iterate(bb_iter, &blk))
|
2011-06-11 02:57:22 +04:00
|
|
|
ext2fs_mark_block_bitmap2(fs->block_map, EXT2FS_B2C(fs, blk));
|
ChangeLog, dumpe2fs.c, mke2fs.c:
dumpe2fs.c: Use WORDS_BIGENDIAN to determine whether or not we're
(not) using i386 byte order.
dumpe2fs.c, mke2fs.c: Stop using the compatibility badblocks function,
and use the ext2fs_badblocks_* functions instead.
ChangeLog, inode.c, tst_iscan.c:
inode.c, tst_iscan.c: Stop using the compatibility badblocks function,
and use the ext2fs_badblocks_* functions instead.
ChangeLog, badblocks.c:
badblocks.c: Stop using the compatibility badblocks function, and use
the ext2fs_badblocks_* functions instead.
2001-06-13 04:12:04 +04:00
|
|
|
ext2fs_badblocks_list_iterate_end(bb_iter);
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
|
|
|
|
2014-01-28 23:44:23 +04:00
|
|
|
static errcode_t packed_allocate_tables(ext2_filsys fs)
|
|
|
|
{
|
|
|
|
errcode_t retval;
|
|
|
|
dgrp_t i;
|
|
|
|
blk64_t goal = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < fs->group_desc_count; i++) {
|
|
|
|
retval = ext2fs_new_block2(fs, goal, NULL, &goal);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
ext2fs_block_alloc_stats2(fs, goal, +1);
|
|
|
|
ext2fs_block_bitmap_loc_set(fs, i, goal);
|
|
|
|
}
|
|
|
|
for (i = 0; i < fs->group_desc_count; i++) {
|
|
|
|
retval = ext2fs_new_block2(fs, goal, NULL, &goal);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
ext2fs_block_alloc_stats2(fs, goal, +1);
|
|
|
|
ext2fs_inode_bitmap_loc_set(fs, i, goal);
|
|
|
|
}
|
|
|
|
for (i = 0; i < fs->group_desc_count; i++) {
|
|
|
|
blk64_t end = ext2fs_blocks_count(fs->super) - 1;
|
|
|
|
retval = ext2fs_get_free_blocks2(fs, goal, end,
|
|
|
|
fs->inode_blocks_per_group,
|
|
|
|
fs->block_map, &goal);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
ext2fs_block_alloc_stats_range(fs, goal,
|
|
|
|
fs->inode_blocks_per_group, +1);
|
|
|
|
ext2fs_inode_table_loc_set(fs, i, goal);
|
2014-05-12 08:21:29 +04:00
|
|
|
ext2fs_group_desc_csum_set(fs, i);
|
2014-01-28 23:44:23 +04:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-08-21 01:41:14 +04:00
|
|
|
static void write_inode_tables(ext2_filsys fs, int lazy_flag, int itable_zeroed)
|
2001-01-16 10:47:31 +03:00
|
|
|
{
|
|
|
|
errcode_t retval;
|
2010-06-13 21:00:00 +04:00
|
|
|
blk64_t blk;
|
2003-12-07 09:28:50 +03:00
|
|
|
dgrp_t i;
|
2010-12-20 18:42:57 +03:00
|
|
|
int num;
|
2009-08-24 03:20:03 +04:00
|
|
|
struct ext2fs_numeric_progress_struct progress;
|
2001-01-16 10:47:31 +03:00
|
|
|
|
2009-08-24 03:20:03 +04:00
|
|
|
ext2fs_numeric_progress_init(fs, &progress,
|
|
|
|
_("Writing inode tables: "),
|
|
|
|
fs->group_desc_count);
|
ChangeLog, mke2fs.c, tune2fs.8.in:
tune2fs.8.in: Fix minor display bug in the nroff.
mke2fs.c (show_stats, write_inode_tables): Use the log10 function to
calculate the display of block numbers so that things look nice on an
80 character display.
mke2fs.c (usage): Add the sparse-super-flag to the usage message.
ChangeLog, e2fsck.c, pass1.c, pass2.c, problem.c, problem.h, unix.c:
unix.c (main): Move ext2fs_close() after e2fsck_free_context() since
e2fsck_free_context may reference data in ctx->fs.
e2fsck.c (e2fsck_reset_context): Make sure ctx->fs is non-NULL before
checking ctx->fs->dblist.
pass1.c (e2fsck_pass1): Use the device check subroutine on FIFO's and
Socket's, so that we catch bogus immutable inodes.
pass2.c (process_bad_inode): Process bad socket and fifo's.
problem.h, problem.c: Define new problem codes PR_2_BAD_FIFO and
PR_2_BAD_SOCKET.
1998-11-14 07:18:28 +03:00
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
for (i = 0; i < fs->group_desc_count; i++) {
|
2012-09-23 05:26:48 +04:00
|
|
|
ext2fs_numeric_progress_update(fs, &progress, i);
|
2008-08-28 07:07:54 +04:00
|
|
|
|
Convert to use block group accessor functions
Convert direct accesses to use the following block group accessor
functions: ext2fs_block_bitmap_loc(), ext2fs_inode_bitmap_loc(),
ext2fs_inode_table_loc(), ext2fs_bg_itable_unused(),
ext2fs_block_bitmap_loc_set(), ext2fs_inode_bitmap_loc_set(),
ext2fs_inode_table_loc_set(), ext2fs_bg_free_inodes_count(),
ext2fs_ext2fs_bg_used_dirs_count(), ext2fs_bg_free_inodes_count_set(),
ext2fs_bg_free_blocks_count_set(), ext2fs_bg_used_dirs_count_set()
Signed-off-by: Valerie Aurora Henson <vaurora@redhat.com>
Signed-off-by: Nick Dokos <nicholas.dokos@hp.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2009-10-26 04:43:47 +03:00
|
|
|
blk = ext2fs_inode_table_loc(fs, i);
|
1997-04-29 20:17:09 +04:00
|
|
|
num = fs->inode_blocks_per_group;
|
2001-01-16 10:47:31 +03:00
|
|
|
|
2010-12-20 18:42:57 +03:00
|
|
|
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));
|
2010-08-21 01:41:14 +04:00
|
|
|
if (!lazy_flag || itable_zeroed) {
|
2007-10-22 06:03:36 +04:00
|
|
|
/* The kernel doesn't need to zero the itable blocks */
|
libext2fs: clean up ext2fs_bg_flags_ interfaces
The ext2fs_bg_flag* functions were confusing.
Currently we have this:
void ext2fs_bg_flags_set(ext2_filsys fs, dgrp_t group, __u16 bg_flags);
void ext2fs_bg_flags_clear(ext2_filsys fs, dgrp_t group,__u16 bg_flags);
(_set (unused) sets exactly bg_flags; _clear clears all and ignores bg_flags)
and these, which can twiddle individual bits in bg_flags:
void ext2fs_bg_flag_set(ext2_filsys fs, dgrp_t group, __u16 bg_flag);
void ext2fs_bg_flag_clear(ext2_filsys fs, dgrp_t group, __u16 bg_flag);
A better interface, after the patch below, is just:
ext2fs_bg_flags_zap(fs, group) /* zeros bg_flags */
ext2fs_bg_flags_set(fs, group, flags) /* adds flags to bg_flags */
ext2fs_bg_flags_clear(fs, group, flags) /* clears flags in bg_flags */
and remove the original ext2fs_bg_flags_set / ext2fs_bg_flags_clear.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2009-10-26 04:41:32 +03:00
|
|
|
ext2fs_bg_flags_set(fs, i, EXT2_BG_INODE_ZEROED);
|
2008-04-21 09:29:01 +04:00
|
|
|
ext2fs_group_desc_csum_set(fs, i);
|
1997-04-29 20:17:09 +04:00
|
|
|
}
|
2010-06-13 21:00:00 +04:00
|
|
|
retval = ext2fs_zero_blocks2(fs, blk, num, &blk, &num);
|
2008-04-23 07:18:37 +04:00
|
|
|
if (retval) {
|
|
|
|
fprintf(stderr, _("\nCould not write %d "
|
2010-06-13 21:00:00 +04:00
|
|
|
"blocks in inode table starting at %llu: %s\n"),
|
2008-04-23 07:18:37 +04:00
|
|
|
num, blk, error_message(retval));
|
|
|
|
exit(1);
|
|
|
|
}
|
1999-02-09 11:14:28 +03:00
|
|
|
if (sync_kludge) {
|
|
|
|
if (sync_kludge == 1)
|
|
|
|
sync();
|
|
|
|
else if ((i % sync_kludge) == 0)
|
|
|
|
sync();
|
|
|
|
}
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
2010-06-13 21:00:00 +04:00
|
|
|
ext2fs_zero_blocks2(0, 0, 0, 0, 0);
|
2009-08-24 03:20:03 +04:00
|
|
|
ext2fs_numeric_progress_close(fs, &progress,
|
|
|
|
_("done \n"));
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void create_root_dir(ext2_filsys fs)
|
|
|
|
{
|
2007-05-08 08:10:54 +04:00
|
|
|
errcode_t retval;
|
1997-04-26 17:34:30 +04:00
|
|
|
struct ext2_inode inode;
|
1997-04-26 17:21:57 +04:00
|
|
|
|
|
|
|
retval = ext2fs_mkdir(fs, EXT2_ROOT_INO, EXT2_ROOT_INO, 0);
|
|
|
|
if (retval) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err("ext2fs_mkdir", retval, "%s",
|
|
|
|
_("while creating root dir"));
|
1997-04-26 17:21:57 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
2013-06-16 05:45:37 +04:00
|
|
|
if (root_uid != 0 || root_gid != 0) {
|
1997-04-26 17:34:30 +04:00
|
|
|
retval = ext2fs_read_inode(fs, EXT2_ROOT_INO, &inode);
|
|
|
|
if (retval) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err("ext2fs_read_inode", retval, "%s",
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
_("while reading root inode"));
|
1997-04-26 17:34:30 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
2013-06-16 05:45:37 +04:00
|
|
|
|
|
|
|
inode.i_uid = root_uid;
|
|
|
|
ext2fs_set_i_uid_high(inode, root_uid >> 16);
|
|
|
|
inode.i_gid = root_gid;
|
|
|
|
ext2fs_set_i_gid_high(inode, root_gid >> 16);
|
|
|
|
|
2005-03-21 09:02:53 +03:00
|
|
|
retval = ext2fs_write_new_inode(fs, EXT2_ROOT_INO, &inode);
|
1997-04-26 17:34:30 +04:00
|
|
|
if (retval) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err("ext2fs_write_inode", retval, "%s",
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
_("while setting root inode ownership"));
|
1997-04-26 17:34:30 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void create_lost_and_found(ext2_filsys fs)
|
|
|
|
{
|
2008-03-18 06:17:13 +03:00
|
|
|
unsigned int lpf_size = 0;
|
1997-04-26 17:21:57 +04:00
|
|
|
errcode_t retval;
|
ChangeLog, libext2fs.texinfo:
libext2fs.texinfo: Change ino_t to ext2_ino_t
ChangeLog, extent.c, main.c, resize2fs.c:
extent.c, main.c, resize2fs.c: Change ino_t to ext2_ino_t.
ChangeLog, mke2fs.c:
mke2fs.c: Change ino_t to ext2_ino_t.
ChangeLog, test_icount.c, test_rel.c:
test_icount.c, test_rel.c: Change ino_t to ext2_ino_t
2001-01-11 18:38:00 +03:00
|
|
|
ext2_ino_t ino;
|
1997-04-26 17:21:57 +04:00
|
|
|
const char *name = "lost+found";
|
|
|
|
int i;
|
|
|
|
|
2001-12-24 17:40:00 +03:00
|
|
|
fs->umask = 077;
|
1997-04-26 17:21:57 +04:00
|
|
|
retval = ext2fs_mkdir(fs, EXT2_ROOT_INO, 0, name);
|
|
|
|
if (retval) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err("ext2fs_mkdir", retval, "%s",
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
_("while creating /lost+found"));
|
1997-04-26 17:21:57 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
retval = ext2fs_lookup(fs, EXT2_ROOT_INO, name, strlen(name), 0, &ino);
|
|
|
|
if (retval) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err("ext2_lookup", retval, "%s",
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
_("while looking up /lost+found"));
|
1997-04-26 17:21:57 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
2008-08-28 07:07:54 +04:00
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
for (i=1; i < EXT2_NDIR_BLOCKS; i++) {
|
2008-01-09 22:59:47 +03:00
|
|
|
/* Ensure that lost+found is at least 2 blocks, so we always
|
|
|
|
* test large empty blocks for big-block filesystems. */
|
|
|
|
if ((lpf_size += fs->blocksize) >= 16*1024 &&
|
|
|
|
lpf_size >= 2 * fs->blocksize)
|
1999-07-19 19:30:21 +04:00
|
|
|
break;
|
1997-04-26 17:21:57 +04:00
|
|
|
retval = ext2fs_expand_dir(fs, ino);
|
|
|
|
if (retval) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err("ext2fs_expand_dir", retval, "%s",
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
_("while expanding /lost+found"));
|
1997-04-26 17:21:57 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
2001-12-24 17:40:00 +03:00
|
|
|
}
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void create_bad_block_inode(ext2_filsys fs, badblocks_list bb_list)
|
|
|
|
{
|
|
|
|
errcode_t retval;
|
2008-08-28 07:07:54 +04:00
|
|
|
|
2009-08-05 08:17:56 +04:00
|
|
|
ext2fs_mark_inode_bitmap2(fs->inode_map, EXT2_BAD_INO);
|
2008-04-21 09:29:01 +04:00
|
|
|
ext2fs_inode_alloc_stats2(fs, EXT2_BAD_INO, +1, 0);
|
1997-04-26 17:21:57 +04:00
|
|
|
retval = ext2fs_update_bb_inode(fs, bb_list);
|
|
|
|
if (retval) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err("ext2fs_update_bb_inode", retval, "%s",
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
_("while setting bad block inode"));
|
1997-04-26 17:21:57 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static void reserve_inodes(ext2_filsys fs)
|
|
|
|
{
|
ChangeLog, libext2fs.texinfo:
libext2fs.texinfo: Change ino_t to ext2_ino_t
ChangeLog, extent.c, main.c, resize2fs.c:
extent.c, main.c, resize2fs.c: Change ino_t to ext2_ino_t.
ChangeLog, mke2fs.c:
mke2fs.c: Change ino_t to ext2_ino_t.
ChangeLog, test_icount.c, test_rel.c:
test_icount.c, test_rel.c: Change ino_t to ext2_ino_t
2001-01-11 18:38:00 +03:00
|
|
|
ext2_ino_t i;
|
1997-04-26 17:21:57 +04:00
|
|
|
|
2008-04-21 09:29:01 +04:00
|
|
|
for (i = EXT2_ROOT_INO + 1; i < EXT2_FIRST_INODE(fs->super); i++)
|
|
|
|
ext2fs_inode_alloc_stats2(fs, i, +1, 0);
|
1997-04-26 17:21:57 +04:00
|
|
|
ext2fs_mark_ib_dirty(fs);
|
|
|
|
}
|
|
|
|
|
2002-03-08 04:52:12 +03:00
|
|
|
#define BSD_DISKMAGIC (0x82564557UL) /* The disk magic number */
|
2002-03-08 11:01:53 +03:00
|
|
|
#define BSD_MAGICDISK (0x57455682UL) /* The disk magic number reversed */
|
2002-03-08 04:52:12 +03:00
|
|
|
#define BSD_LABEL_OFFSET 64
|
|
|
|
|
2001-08-31 05:55:26 +04:00
|
|
|
static void zap_sector(ext2_filsys fs, int sect, int nsect)
|
1997-04-26 17:34:30 +04:00
|
|
|
{
|
2001-09-17 18:38:06 +04:00
|
|
|
char *buf;
|
1997-04-26 17:34:30 +04:00
|
|
|
int retval;
|
2002-03-08 04:52:12 +03:00
|
|
|
unsigned int *magic;
|
1997-04-26 17:34:30 +04:00
|
|
|
|
2001-09-17 18:38:06 +04:00
|
|
|
buf = malloc(512*nsect);
|
2001-10-13 11:22:25 +04:00
|
|
|
if (!buf) {
|
2001-12-17 07:23:37 +03:00
|
|
|
printf(_("Out of memory erasing sectors %d-%d\n"),
|
|
|
|
sect, sect + nsect - 1);
|
2001-10-13 11:22:25 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
2002-03-08 04:52:12 +03:00
|
|
|
|
2002-03-08 11:01:53 +03:00
|
|
|
if (sect == 0) {
|
|
|
|
/* Check for a BSD disklabel, and don't erase it if so */
|
2009-09-08 05:14:24 +04:00
|
|
|
retval = io_channel_read_blk64(fs->io, 0, -512, buf);
|
2002-03-08 11:01:53 +03:00
|
|
|
if (retval)
|
|
|
|
fprintf(stderr,
|
|
|
|
_("Warning: could not read block 0: %s\n"),
|
|
|
|
error_message(retval));
|
|
|
|
else {
|
|
|
|
magic = (unsigned int *) (buf + BSD_LABEL_OFFSET);
|
|
|
|
if ((*magic == BSD_DISKMAGIC) ||
|
|
|
|
(*magic == BSD_MAGICDISK))
|
|
|
|
return;
|
|
|
|
}
|
2002-03-08 04:52:12 +03:00
|
|
|
}
|
|
|
|
|
2002-07-14 16:00:00 +04:00
|
|
|
memset(buf, 0, 512*nsect);
|
2000-08-14 18:44:15 +04:00
|
|
|
io_channel_set_blksize(fs->io, 512);
|
2009-09-08 05:14:24 +04:00
|
|
|
retval = io_channel_write_blk64(fs->io, sect, -512*nsect, buf);
|
2000-08-14 18:44:15 +04:00
|
|
|
io_channel_set_blksize(fs->io, fs->blocksize);
|
2001-09-17 18:38:06 +04:00
|
|
|
free(buf);
|
1997-04-26 17:34:30 +04:00
|
|
|
if (retval)
|
2002-03-08 08:14:46 +03:00
|
|
|
fprintf(stderr, _("Warning: could not erase sector %d: %s\n"),
|
|
|
|
sect, error_message(retval));
|
1997-04-26 17:34:30 +04:00
|
|
|
}
|
2001-01-16 10:47:31 +03:00
|
|
|
|
|
|
|
static void create_journal_dev(ext2_filsys fs)
|
|
|
|
{
|
2009-08-24 03:20:03 +04:00
|
|
|
struct ext2fs_numeric_progress_struct progress;
|
2001-01-16 10:47:31 +03:00
|
|
|
errcode_t retval;
|
|
|
|
char *buf;
|
2010-06-13 21:00:00 +04:00
|
|
|
blk64_t blk, err_blk;
|
2007-08-13 14:26:26 +04:00
|
|
|
int c, count, err_count;
|
2001-01-16 10:47:31 +03:00
|
|
|
|
2001-04-17 06:34:41 +04:00
|
|
|
retval = ext2fs_create_journal_superblock(fs,
|
2009-09-08 04:46:34 +04:00
|
|
|
ext2fs_blocks_count(fs->super), 0, &buf);
|
2001-04-17 06:34:41 +04:00
|
|
|
if (retval) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err("create_journal_dev", retval, "%s",
|
2001-04-17 06:34:41 +04:00
|
|
|
_("while initializing journal superblock"));
|
|
|
|
exit(1);
|
|
|
|
}
|
2011-06-11 20:17:29 +04:00
|
|
|
|
|
|
|
if (journal_flags & EXT2_MKJOURNAL_LAZYINIT)
|
|
|
|
goto write_superblock;
|
|
|
|
|
2009-08-24 03:20:03 +04:00
|
|
|
ext2fs_numeric_progress_init(fs, &progress,
|
|
|
|
_("Zeroing journal device: "),
|
|
|
|
ext2fs_blocks_count(fs->super));
|
2007-08-13 14:26:26 +04:00
|
|
|
blk = 0;
|
2009-09-08 04:46:34 +04:00
|
|
|
count = ext2fs_blocks_count(fs->super);
|
2007-08-13 14:26:26 +04:00
|
|
|
while (count > 0) {
|
|
|
|
if (count > 1024)
|
|
|
|
c = 1024;
|
|
|
|
else
|
|
|
|
c = count;
|
2010-06-13 21:00:00 +04:00
|
|
|
retval = ext2fs_zero_blocks2(fs, blk, c, &err_blk, &err_count);
|
2007-08-13 14:26:26 +04:00
|
|
|
if (retval) {
|
|
|
|
com_err("create_journal_dev", retval,
|
|
|
|
_("while zeroing journal device "
|
2010-06-13 21:00:00 +04:00
|
|
|
"(block %llu, count %d)"),
|
2007-08-13 14:26:26 +04:00
|
|
|
err_blk, err_count);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
blk += c;
|
|
|
|
count -= c;
|
2012-09-23 05:26:48 +04:00
|
|
|
ext2fs_numeric_progress_update(fs, &progress, blk);
|
2001-01-16 10:47:31 +03:00
|
|
|
}
|
2010-06-13 21:00:00 +04:00
|
|
|
ext2fs_zero_blocks2(0, 0, 0, 0, 0);
|
ChangeLog, mke2fs.8.in, mke2fs.c, tune2fs.8.in, tune2fs.c:
tune2fs.c, mke2fs.c, tune2fs.8.in, mke2fs.8.in: Change user interface
so that -J is used to specify journal options, and -j is used to
request creation of a journal using default values. (This is a UI
change, but we haven't done a formal release, and it makes things much
more consistent with the rest of the options out there.)
tune2fs.c: Add support for removing a filesystem from an external
journal; we correctly remove the filesystem UUID from the external
journal's filesystem list.
2001-01-18 04:51:15 +03:00
|
|
|
|
2011-06-11 20:17:29 +04:00
|
|
|
ext2fs_numeric_progress_close(fs, &progress, NULL);
|
|
|
|
write_superblock:
|
2009-09-08 05:14:24 +04:00
|
|
|
retval = io_channel_write_blk64(fs->io,
|
|
|
|
fs->super->s_first_data_block+1,
|
|
|
|
1, buf);
|
2001-01-16 10:47:31 +03:00
|
|
|
if (retval) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err("create_journal_dev", retval, "%s",
|
2001-01-16 10:47:31 +03:00
|
|
|
_("while writing journal superblock"));
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
1997-04-26 17:34:30 +04:00
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
static void show_stats(ext2_filsys fs)
|
|
|
|
{
|
2001-01-01 18:31:53 +03:00
|
|
|
struct ext2_super_block *s = fs->super;
|
1997-04-29 18:53:37 +04:00
|
|
|
char buf[80];
|
2005-03-19 09:13:22 +03:00
|
|
|
char *os;
|
2010-06-13 21:00:00 +04:00
|
|
|
blk64_t group_block;
|
2003-12-07 09:28:50 +03:00
|
|
|
dgrp_t i;
|
|
|
|
int need, col_left;
|
2008-08-28 07:07:54 +04:00
|
|
|
|
2014-04-27 03:00:50 +04:00
|
|
|
if (!verbose) {
|
|
|
|
printf(_("Creating filesystem with %llu %dk blocks and "
|
|
|
|
"%u inodes\n"),
|
|
|
|
ext2fs_blocks_count(s), fs->blocksize >> 10,
|
|
|
|
s->s_inodes_count);
|
|
|
|
goto skip_details;
|
|
|
|
}
|
|
|
|
|
2009-09-08 04:46:34 +04:00
|
|
|
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));
|
1999-07-19 19:30:21 +04:00
|
|
|
|
|
|
|
memset(buf, 0, sizeof(buf));
|
|
|
|
strncpy(buf, s->s_volume_name, sizeof(s->s_volume_name));
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
printf(_("Filesystem label=%s\n"), buf);
|
2010-12-22 02:12:12 +03:00
|
|
|
os = e2p_os2string(fs->super->s_creator_os);
|
|
|
|
if (os)
|
|
|
|
printf(_("OS type: %s\n"), os);
|
2005-03-19 09:13:22 +03:00
|
|
|
free(os);
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
printf(_("Block size=%u (log=%u)\n"), fs->blocksize,
|
1999-07-19 19:30:21 +04:00
|
|
|
s->s_log_block_size);
|
2011-02-26 05:43:54 +03:00
|
|
|
if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
|
|
|
|
EXT4_FEATURE_RO_COMPAT_BIGALLOC))
|
|
|
|
printf(_("Cluster size=%u (log=%u)\n"),
|
2011-06-04 18:20:47 +04:00
|
|
|
fs->blocksize << fs->cluster_ratio_bits,
|
|
|
|
s->s_log_cluster_size);
|
2011-02-26 05:43:54 +03:00
|
|
|
else
|
2011-06-04 18:20:47 +04:00
|
|
|
printf(_("Fragment size=%u (log=%u)\n"), EXT2_CLUSTER_SIZE(s),
|
2011-02-26 05:43:54 +03:00
|
|
|
s->s_log_cluster_size);
|
2009-10-02 20:32:42 +04:00
|
|
|
printf(_("Stride=%u blocks, Stripe width=%u blocks\n"),
|
|
|
|
s->s_raid_stride, s->s_raid_stripe_width);
|
2009-09-08 04:46:34 +04:00
|
|
|
printf(_("%u inodes, %llu blocks\n"), s->s_inodes_count,
|
|
|
|
ext2fs_blocks_count(s));
|
|
|
|
printf(_("%llu blocks (%2.2f%%) reserved for the super user\n"),
|
|
|
|
ext2fs_r_blocks_count(s),
|
|
|
|
100.0 * ext2fs_r_blocks_count(s) / ext2fs_blocks_count(s));
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
printf(_("First data block=%u\n"), s->s_first_data_block);
|
2013-06-16 05:45:37 +04:00
|
|
|
if (root_uid != 0 || root_gid != 0)
|
|
|
|
printf(_("Root directory owner=%u:%u\n"), root_uid, root_gid);
|
2004-12-15 22:39:16 +03:00
|
|
|
if (s->s_reserved_gdt_blocks)
|
|
|
|
printf(_("Maximum filesystem blocks=%lu\n"),
|
|
|
|
(s->s_reserved_gdt_blocks + fs->desc_blocks) *
|
2007-08-30 19:38:13 +04:00
|
|
|
EXT2_DESC_PER_BLOCK(s) * s->s_blocks_per_group);
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
if (fs->group_desc_count > 1)
|
ChangeLog, e2image.c, mke2fs.c, mklost+found.c, tune2fs.c, util.c, uuidgen.c:
e2image.c, mke2fs.c, mklost+found.c, tune2fs.c, util.c, uuidgen.c: Fix
gcc -Wall complaints, including one bug in tune2fs caused by a block
automatic shadowing version of the variable we really wanted to use,
which broke the logic testing to see if the filesystem was mounted.
ChangeLog, MCONFIG.in:
(gcc-wall-new): Added new target which forgoes the make clean so we
only check the newly modified .c files.
2001-01-11 19:08:23 +03:00
|
|
|
printf(_("%u block groups\n"), fs->group_desc_count);
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
else
|
ChangeLog, e2image.c, mke2fs.c, mklost+found.c, tune2fs.c, util.c, uuidgen.c:
e2image.c, mke2fs.c, mklost+found.c, tune2fs.c, util.c, uuidgen.c: Fix
gcc -Wall complaints, including one bug in tune2fs caused by a block
automatic shadowing version of the variable we really wanted to use,
which broke the logic testing to see if the filesystem was mounted.
ChangeLog, MCONFIG.in:
(gcc-wall-new): Added new target which forgoes the make clean so we
only check the newly modified .c files.
2001-01-11 19:08:23 +03:00
|
|
|
printf(_("%u block group\n"), fs->group_desc_count);
|
2011-02-26 05:43:54 +03:00
|
|
|
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);
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
printf(_("%u inodes per group\n"), s->s_inodes_per_group);
|
1997-04-26 17:21:57 +04:00
|
|
|
|
2014-04-27 03:00:50 +04:00
|
|
|
skip_details:
|
1997-04-26 17:21:57 +04:00
|
|
|
if (fs->group_desc_count == 1) {
|
|
|
|
printf("\n");
|
|
|
|
return;
|
|
|
|
}
|
2004-12-15 22:39:16 +03:00
|
|
|
|
2014-04-27 03:00:50 +04:00
|
|
|
if (!e2p_is_null_uuid(s->s_uuid))
|
|
|
|
printf(_("Filesystem UUID: %s\n"), e2p_uuid2str(s->s_uuid));
|
2013-12-16 07:11:40 +04:00
|
|
|
printf("%s", _("Superblock backups stored on blocks: "));
|
1997-04-26 17:21:57 +04:00
|
|
|
group_block = s->s_first_data_block;
|
|
|
|
col_left = 0;
|
|
|
|
for (i = 1; i < fs->group_desc_count; i++) {
|
|
|
|
group_block += s->s_blocks_per_group;
|
1997-04-29 21:48:10 +04:00
|
|
|
if (!ext2fs_bg_has_super(fs, i))
|
|
|
|
continue;
|
1999-10-20 22:06:29 +04:00
|
|
|
if (i != 1)
|
|
|
|
printf(", ");
|
1999-11-23 05:23:30 +03:00
|
|
|
need = int_log10(group_block) + 2;
|
ChangeLog, mke2fs.c, tune2fs.8.in:
tune2fs.8.in: Fix minor display bug in the nroff.
mke2fs.c (show_stats, write_inode_tables): Use the log10 function to
calculate the display of block numbers so that things look nice on an
80 character display.
mke2fs.c (usage): Add the sparse-super-flag to the usage message.
ChangeLog, e2fsck.c, pass1.c, pass2.c, problem.c, problem.h, unix.c:
unix.c (main): Move ext2fs_close() after e2fsck_free_context() since
e2fsck_free_context may reference data in ctx->fs.
e2fsck.c (e2fsck_reset_context): Make sure ctx->fs is non-NULL before
checking ctx->fs->dblist.
pass1.c (e2fsck_pass1): Use the device check subroutine on FIFO's and
Socket's, so that we catch bogus immutable inodes.
pass2.c (process_bad_inode): Process bad socket and fifo's.
problem.h, problem.c: Define new problem codes PR_2_BAD_FIFO and
PR_2_BAD_SOCKET.
1998-11-14 07:18:28 +03:00
|
|
|
if (need > col_left) {
|
1997-04-26 17:21:57 +04:00
|
|
|
printf("\n\t");
|
ChangeLog, mke2fs.c, tune2fs.8.in:
tune2fs.8.in: Fix minor display bug in the nroff.
mke2fs.c (show_stats, write_inode_tables): Use the log10 function to
calculate the display of block numbers so that things look nice on an
80 character display.
mke2fs.c (usage): Add the sparse-super-flag to the usage message.
ChangeLog, e2fsck.c, pass1.c, pass2.c, problem.c, problem.h, unix.c:
unix.c (main): Move ext2fs_close() after e2fsck_free_context() since
e2fsck_free_context may reference data in ctx->fs.
e2fsck.c (e2fsck_reset_context): Make sure ctx->fs is non-NULL before
checking ctx->fs->dblist.
pass1.c (e2fsck_pass1): Use the device check subroutine on FIFO's and
Socket's, so that we catch bogus immutable inodes.
pass2.c (process_bad_inode): Process bad socket and fifo's.
problem.h, problem.c: Define new problem codes PR_2_BAD_FIFO and
PR_2_BAD_SOCKET.
1998-11-14 07:18:28 +03:00
|
|
|
col_left = 72;
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
ChangeLog, mke2fs.c, tune2fs.8.in:
tune2fs.8.in: Fix minor display bug in the nroff.
mke2fs.c (show_stats, write_inode_tables): Use the log10 function to
calculate the display of block numbers so that things look nice on an
80 character display.
mke2fs.c (usage): Add the sparse-super-flag to the usage message.
ChangeLog, e2fsck.c, pass1.c, pass2.c, problem.c, problem.h, unix.c:
unix.c (main): Move ext2fs_close() after e2fsck_free_context() since
e2fsck_free_context may reference data in ctx->fs.
e2fsck.c (e2fsck_reset_context): Make sure ctx->fs is non-NULL before
checking ctx->fs->dblist.
pass1.c (e2fsck_pass1): Use the device check subroutine on FIFO's and
Socket's, so that we catch bogus immutable inodes.
pass2.c (process_bad_inode): Process bad socket and fifo's.
problem.h, problem.c: Define new problem codes PR_2_BAD_FIFO and
PR_2_BAD_SOCKET.
1998-11-14 07:18:28 +03:00
|
|
|
col_left -= need;
|
2010-06-13 21:00:00 +04:00
|
|
|
printf("%llu", group_block);
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
|
|
|
printf("\n\n");
|
|
|
|
}
|
|
|
|
|
1997-04-29 18:53:37 +04:00
|
|
|
/*
|
|
|
|
* Set the S_CREATOR_OS field. Return true if OS is known,
|
|
|
|
* otherwise, 0.
|
|
|
|
*/
|
|
|
|
static int set_os(struct ext2_super_block *sb, char *os)
|
|
|
|
{
|
|
|
|
if (isdigit (*os))
|
|
|
|
sb->s_creator_os = atoi (os);
|
|
|
|
else if (strcasecmp(os, "linux") == 0)
|
|
|
|
sb->s_creator_os = EXT2_OS_LINUX;
|
|
|
|
else if (strcasecmp(os, "GNU") == 0 || strcasecmp(os, "hurd") == 0)
|
|
|
|
sb->s_creator_os = EXT2_OS_HURD;
|
2005-01-20 02:18:44 +03:00
|
|
|
else if (strcasecmp(os, "freebsd") == 0)
|
|
|
|
sb->s_creator_os = EXT2_OS_FREEBSD;
|
|
|
|
else if (strcasecmp(os, "lites") == 0)
|
|
|
|
sb->s_creator_os = EXT2_OS_LITES;
|
1997-04-29 18:53:37 +04:00
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
1997-04-26 18:00:26 +04:00
|
|
|
#define PATH_SET "PATH=/sbin"
|
|
|
|
|
2008-08-28 07:07:54 +04:00
|
|
|
static void parse_extended_opts(struct ext2_super_block *param,
|
2005-01-05 19:12:20 +03:00
|
|
|
const char *opts)
|
1997-04-30 01:26:48 +04:00
|
|
|
{
|
2008-03-18 06:17:13 +03:00
|
|
|
char *buf, *token, *next, *p, *arg, *badopt = 0;
|
1997-04-30 01:26:48 +04:00
|
|
|
int len;
|
2004-12-15 22:39:16 +03:00
|
|
|
int r_usage = 0;
|
1997-04-30 01:26:48 +04:00
|
|
|
|
|
|
|
len = strlen(opts);
|
|
|
|
buf = malloc(len+1);
|
|
|
|
if (!buf) {
|
2013-12-16 07:11:40 +04:00
|
|
|
fprintf(stderr, "%s",
|
2004-12-15 22:39:16 +03:00
|
|
|
_("Couldn't allocate memory to parse options!\n"));
|
1997-04-30 01:26:48 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
strcpy(buf, opts);
|
|
|
|
for (token = buf; token && *token; token = next) {
|
|
|
|
p = strchr(token, ',');
|
|
|
|
next = 0;
|
|
|
|
if (p) {
|
|
|
|
*p = 0;
|
|
|
|
next = p+1;
|
2004-12-15 22:39:16 +03:00
|
|
|
}
|
1997-04-30 01:26:48 +04:00
|
|
|
arg = strchr(token, '=');
|
|
|
|
if (arg) {
|
|
|
|
*arg = 0;
|
|
|
|
arg++;
|
|
|
|
}
|
debugfs, e2fsck: fix s_desc_size handling
The s_desc_size in the superblock specifies the group descriptor
size in bytes, but in various places the EXT4_FEATURE_INCOMPAT_64BIT
flag implies that the descriptor size is EXT2_MIN_DESC_SIZE_64BIT
(64 bytes) instead of checking the actual size. In other places,
the s_desc_size field is used without checking for INCOMPAT_64BIT.
In the case of ext2fs_group_desc() the s_desc_size was being ignored,
and assumed to be sizeof(struct ext4_group_desc), which would result
in garbage for any but the first group descriptor. Similarly, in
ext2fs_group_desc_csum() and print_csum() they assumed that the
maximum group descriptor size was sizeof(struct ext4_group_desc).
Fix these functions to use the actual superblock s_desc_size if
INCOMPAT_64BIT.
Conversely, in ext2fs_swap_group_desc2() s_desc_size was used
without checking for INCOMPAT_64BIT being set.
The e2fsprogs behaviour is different than that of the kernel,
which always checks INCOMPAT_64BIT, and only uses s_desc_size to
determine the offset of group descriptors and what range of bytes
to checksum.
Allow specifying the s_desc_size field at mke2fs time with the
"-E desc_size=NNN" option. Allow a power-of-two s_desc_size
value up to s_blocksize if INCOMPAT_64BIT is specified. This
is not expected to be used by regular users at this time, so it
is not currently documented in the mke2fs usage or man page.
Add m_desc_size_128, f_desc_size_128, and f_desc_bad test cases to
verify mke2fs and e2fsck handling of larger group descriptor sizes.
Signed-off-by: Andreas Dilger <adilger@dilger.ca>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2013-12-24 01:04:46 +04:00
|
|
|
if (strcmp(token, "desc-size") == 0 ||
|
|
|
|
strcmp(token, "desc_size") == 0) {
|
|
|
|
int desc_size;
|
|
|
|
|
|
|
|
if (!(fs_param.s_feature_incompat &
|
|
|
|
EXT4_FEATURE_INCOMPAT_64BIT)) {
|
|
|
|
fprintf(stderr,
|
|
|
|
_("%s requires '-O 64bit'\n"), token);
|
|
|
|
r_usage++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (param->s_reserved_gdt_blocks != 0) {
|
|
|
|
fprintf(stderr,
|
|
|
|
_("'%s' must be before 'resize=%u'\n"),
|
|
|
|
token, param->s_reserved_gdt_blocks);
|
|
|
|
r_usage++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!arg) {
|
|
|
|
r_usage++;
|
|
|
|
badopt = token;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
desc_size = strtoul(arg, &p, 0);
|
|
|
|
if (*p || (desc_size & (desc_size - 1))) {
|
|
|
|
fprintf(stderr,
|
|
|
|
_("Invalid desc_size: '%s'\n"), arg);
|
|
|
|
r_usage++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
param->s_desc_size = desc_size;
|
2013-12-31 08:03:09 +04:00
|
|
|
} else if (strcmp(token, "offset") == 0) {
|
|
|
|
if (!arg) {
|
|
|
|
r_usage++;
|
|
|
|
badopt = token;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
offset = strtoull(arg, &p, 0);
|
|
|
|
if (*p) {
|
|
|
|
fprintf(stderr, _("Invalid offset: %s\n"),
|
|
|
|
arg);
|
|
|
|
r_usage++;
|
|
|
|
continue;
|
|
|
|
}
|
debugfs, e2fsck: fix s_desc_size handling
The s_desc_size in the superblock specifies the group descriptor
size in bytes, but in various places the EXT4_FEATURE_INCOMPAT_64BIT
flag implies that the descriptor size is EXT2_MIN_DESC_SIZE_64BIT
(64 bytes) instead of checking the actual size. In other places,
the s_desc_size field is used without checking for INCOMPAT_64BIT.
In the case of ext2fs_group_desc() the s_desc_size was being ignored,
and assumed to be sizeof(struct ext4_group_desc), which would result
in garbage for any but the first group descriptor. Similarly, in
ext2fs_group_desc_csum() and print_csum() they assumed that the
maximum group descriptor size was sizeof(struct ext4_group_desc).
Fix these functions to use the actual superblock s_desc_size if
INCOMPAT_64BIT.
Conversely, in ext2fs_swap_group_desc2() s_desc_size was used
without checking for INCOMPAT_64BIT being set.
The e2fsprogs behaviour is different than that of the kernel,
which always checks INCOMPAT_64BIT, and only uses s_desc_size to
determine the offset of group descriptors and what range of bytes
to checksum.
Allow specifying the s_desc_size field at mke2fs time with the
"-E desc_size=NNN" option. Allow a power-of-two s_desc_size
value up to s_blocksize if INCOMPAT_64BIT is specified. This
is not expected to be used by regular users at this time, so it
is not currently documented in the mke2fs usage or man page.
Add m_desc_size_128, f_desc_size_128, and f_desc_bad test cases to
verify mke2fs and e2fsck handling of larger group descriptor sizes.
Signed-off-by: Andreas Dilger <adilger@dilger.ca>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2013-12-24 01:04:46 +04:00
|
|
|
} else if (strcmp(token, "mmp_update_interval") == 0) {
|
2011-09-24 21:48:55 +04:00
|
|
|
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;
|
|
|
|
}
|
2014-01-12 07:11:42 +04:00
|
|
|
} else if (strcmp(token, "num_backup_sb") == 0) {
|
|
|
|
if (!arg) {
|
|
|
|
r_usage++;
|
|
|
|
badopt = token;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
num_backups = strtoul(arg, &p, 0);
|
|
|
|
if (*p || num_backups > 2) {
|
|
|
|
fprintf(stderr,
|
|
|
|
_("Invalid # of backup "
|
2014-06-02 05:12:47 +04:00
|
|
|
"superblocks: %s\n"),
|
2014-01-12 07:11:42 +04:00
|
|
|
arg);
|
|
|
|
r_usage++;
|
|
|
|
continue;
|
|
|
|
}
|
2014-01-28 23:44:23 +04:00
|
|
|
} else if (strcmp(token, "packed_meta_blocks") == 0) {
|
|
|
|
if (arg)
|
|
|
|
packed_meta_blocks = strtoul(arg, &p, 0);
|
|
|
|
else
|
|
|
|
packed_meta_blocks = 1;
|
|
|
|
if (packed_meta_blocks)
|
|
|
|
journal_location = 0;
|
2011-09-24 21:48:55 +04:00
|
|
|
} else if (strcmp(token, "stride") == 0) {
|
1997-04-30 01:26:48 +04:00
|
|
|
if (!arg) {
|
2004-12-15 22:39:16 +03:00
|
|
|
r_usage++;
|
2008-02-19 06:56:25 +03:00
|
|
|
badopt = token;
|
1997-04-30 01:26:48 +04:00
|
|
|
continue;
|
|
|
|
}
|
2008-02-19 06:56:25 +03:00
|
|
|
param->s_raid_stride = strtoul(arg, &p, 0);
|
2011-07-05 04:22:19 +04:00
|
|
|
if (*p) {
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
fprintf(stderr,
|
2005-05-06 07:15:55 +04:00
|
|
|
_("Invalid stride parameter: %s\n"),
|
|
|
|
arg);
|
2004-12-15 22:39:16 +03:00
|
|
|
r_usage++;
|
|
|
|
continue;
|
|
|
|
}
|
2008-02-19 06:56:25 +03:00
|
|
|
} 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);
|
2011-07-05 04:22:19 +04:00
|
|
|
if (*p) {
|
2008-02-19 06:56:25 +03:00
|
|
|
fprintf(stderr,
|
|
|
|
_("Invalid stripe-width parameter: %s\n"),
|
|
|
|
arg);
|
|
|
|
r_usage++;
|
|
|
|
continue;
|
|
|
|
}
|
2004-12-15 22:39:16 +03:00
|
|
|
} else if (!strcmp(token, "resize")) {
|
2010-06-13 21:00:00 +04:00
|
|
|
blk64_t resize;
|
|
|
|
unsigned long bpg, rsv_groups;
|
2005-01-05 19:12:20 +03:00
|
|
|
unsigned long group_desc_count, desc_blocks;
|
|
|
|
unsigned int gdpb, blocksize;
|
|
|
|
int rsv_gdb;
|
2004-12-15 22:39:16 +03:00
|
|
|
|
|
|
|
if (!arg) {
|
|
|
|
r_usage++;
|
2008-02-19 06:56:25 +03:00
|
|
|
badopt = token;
|
1997-04-30 01:26:48 +04:00
|
|
|
continue;
|
|
|
|
}
|
2004-12-15 22:39:16 +03:00
|
|
|
|
2010-06-13 21:00:00 +04:00
|
|
|
resize = parse_num_blocks2(arg,
|
|
|
|
param->s_log_block_size);
|
2004-12-15 22:39:16 +03:00
|
|
|
|
|
|
|
if (resize == 0) {
|
2008-08-28 07:07:54 +04:00
|
|
|
fprintf(stderr,
|
2005-01-05 11:01:06 +03:00
|
|
|
_("Invalid resize parameter: %s\n"),
|
|
|
|
arg);
|
2004-12-15 22:39:16 +03:00
|
|
|
r_usage++;
|
|
|
|
continue;
|
|
|
|
}
|
2009-09-08 04:46:34 +04:00
|
|
|
if (resize <= ext2fs_blocks_count(param)) {
|
2013-12-16 07:11:40 +04:00
|
|
|
fprintf(stderr, "%s",
|
2005-05-06 07:15:55 +04:00
|
|
|
_("The resize maximum must be greater "
|
|
|
|
"than the filesystem size.\n"));
|
2005-01-05 19:12:20 +03:00
|
|
|
r_usage++;
|
|
|
|
continue;
|
|
|
|
}
|
2004-12-15 22:39:16 +03:00
|
|
|
|
2005-01-05 19:12:20 +03:00
|
|
|
blocksize = EXT2_BLOCK_SIZE(param);
|
|
|
|
bpg = param->s_blocks_per_group;
|
|
|
|
if (!bpg)
|
|
|
|
bpg = blocksize * 8;
|
2007-08-30 19:38:13 +04:00
|
|
|
gdpb = EXT2_DESC_PER_BLOCK(param);
|
2009-09-08 04:46:34 +04:00
|
|
|
group_desc_count = (__u32) ext2fs_div64_ceil(
|
|
|
|
ext2fs_blocks_count(param), bpg);
|
2005-01-05 19:12:20 +03:00
|
|
|
desc_blocks = (group_desc_count +
|
|
|
|
gdpb - 1) / gdpb;
|
2010-06-13 21:00:00 +04:00
|
|
|
rsv_groups = ext2fs_div64_ceil(resize, bpg);
|
2008-08-28 07:07:54 +04:00
|
|
|
rsv_gdb = ext2fs_div_ceil(rsv_groups, gdpb) -
|
2005-01-05 19:12:20 +03:00
|
|
|
desc_blocks;
|
2005-12-11 05:50:30 +03:00
|
|
|
if (rsv_gdb > (int) EXT2_ADDR_PER_BLOCK(param))
|
2005-01-05 19:12:20 +03:00
|
|
|
rsv_gdb = EXT2_ADDR_PER_BLOCK(param);
|
|
|
|
|
|
|
|
if (rsv_gdb > 0) {
|
2006-10-18 08:31:11 +04:00
|
|
|
if (param->s_rev_level == EXT2_GOOD_OLD_REV) {
|
2013-12-16 07:11:40 +04:00
|
|
|
fprintf(stderr, "%s",
|
2006-10-18 08:31:11 +04:00
|
|
|
_("On-line resizing not supported with revision 0 filesystems\n"));
|
2007-05-31 19:30:47 +04:00
|
|
|
free(buf);
|
2006-10-18 08:31:11 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
2005-01-05 19:12:20 +03:00
|
|
|
param->s_feature_compat |=
|
|
|
|
EXT2_FEATURE_COMPAT_RESIZE_INODE;
|
|
|
|
|
|
|
|
param->s_reserved_gdt_blocks = rsv_gdb;
|
|
|
|
}
|
2008-01-27 03:06:35 +03:00
|
|
|
} else if (!strcmp(token, "test_fs")) {
|
|
|
|
param->s_flags |= EXT2_FLAGS_TEST_FILESYS;
|
2008-04-18 18:19:27 +04:00
|
|
|
} else if (!strcmp(token, "lazy_itable_init")) {
|
2008-04-28 03:38:02 +04:00
|
|
|
if (arg)
|
|
|
|
lazy_itable_init = strtoul(arg, &p, 0);
|
|
|
|
else
|
|
|
|
lazy_itable_init = 1;
|
2011-06-11 20:17:29 +04:00
|
|
|
} 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;
|
2013-06-16 05:45:37 +04:00
|
|
|
} else if (!strcmp(token, "root_owner")) {
|
|
|
|
if (arg) {
|
|
|
|
root_uid = strtoul(arg, &p, 0);
|
|
|
|
if (*p != ':') {
|
|
|
|
fprintf(stderr,
|
|
|
|
_("Invalid root_owner: '%s'\n"),
|
|
|
|
arg);
|
|
|
|
r_usage++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
p++;
|
|
|
|
root_gid = strtoul(p, &p, 0);
|
|
|
|
if (*p) {
|
|
|
|
fprintf(stderr,
|
|
|
|
_("Invalid root_owner: '%s'\n"),
|
|
|
|
arg);
|
|
|
|
r_usage++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
root_uid = getuid();
|
|
|
|
root_gid = getgid();
|
|
|
|
}
|
2010-11-18 16:38:39 +03:00
|
|
|
} else if (!strcmp(token, "discard")) {
|
|
|
|
discard = 1;
|
|
|
|
} else if (!strcmp(token, "nodiscard")) {
|
|
|
|
discard = 0;
|
2011-11-14 19:55:54 +04:00
|
|
|
} 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;
|
|
|
|
}
|
2008-02-19 06:56:25 +03:00
|
|
|
} else {
|
2004-12-15 22:39:16 +03:00
|
|
|
r_usage++;
|
2008-02-19 06:56:25 +03:00
|
|
|
badopt = token;
|
|
|
|
}
|
1997-04-30 01:26:48 +04:00
|
|
|
}
|
2004-12-15 22:39:16 +03:00
|
|
|
if (r_usage) {
|
2008-02-19 06:56:25 +03:00
|
|
|
fprintf(stderr, _("\nBad option(s) specified: %s\n\n"
|
2005-06-20 16:35:27 +04:00
|
|
|
"Extended options are separated by commas, "
|
1997-04-30 01:26:48 +04:00
|
|
|
"and may take an argument which\n"
|
|
|
|
"\tis set off by an equals ('=') sign.\n\n"
|
2005-06-20 16:35:27 +04:00
|
|
|
"Valid extended options are:\n"
|
2013-12-31 08:03:09 +04:00
|
|
|
"\tmmp_update_interval=<interval>\n"
|
2014-01-12 07:11:42 +04:00
|
|
|
"\tnum_backup_sb=<0|1|2>\n"
|
2008-02-19 06:56:25 +03:00
|
|
|
"\tstride=<RAID per-disk data chunk in blocks>\n"
|
|
|
|
"\tstripe-width=<RAID stride * data disks in blocks>\n"
|
2013-12-31 08:03:09 +04:00
|
|
|
"\toffset=<offset to create the file system>\n"
|
2008-04-18 18:19:27 +04:00
|
|
|
"\tresize=<resize maximum size in blocks>\n"
|
2014-01-28 23:44:23 +04:00
|
|
|
"\tpacked_meta_blocks=<0 to disable, 1 to enable>\n"
|
2008-04-18 18:19:27 +04:00
|
|
|
"\tlazy_itable_init=<0 to disable, 1 to enable>\n"
|
2011-06-11 20:17:29 +04:00
|
|
|
"\tlazy_journal_init=<0 to disable, 1 to enable>\n"
|
2013-06-16 05:45:37 +04:00
|
|
|
"\troot_uid=<uid of root directory>\n"
|
|
|
|
"\troot_gid=<gid of root directory>\n"
|
2010-11-18 16:38:39 +03:00
|
|
|
"\ttest_fs\n"
|
|
|
|
"\tdiscard\n"
|
2011-11-14 19:55:54 +04:00
|
|
|
"\tnodiscard\n"
|
|
|
|
"\tquotatype=<usr OR grp>\n\n"),
|
2008-03-18 06:17:13 +03:00
|
|
|
badopt ? badopt : "");
|
2007-05-31 19:30:47 +04:00
|
|
|
free(buf);
|
1997-04-30 01:26:48 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
2008-02-19 06:56:25 +03:00
|
|
|
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);
|
|
|
|
|
2007-05-31 19:30:47 +04:00
|
|
|
free(buf);
|
2008-08-28 07:07:54 +04:00
|
|
|
}
|
1997-04-30 01:26:48 +04:00
|
|
|
|
1999-10-23 05:04:50 +04:00
|
|
|
static __u32 ok_features[3] = {
|
2008-02-27 23:01:19 +03:00
|
|
|
/* Compat */
|
2002-09-22 23:37:40 +04:00
|
|
|
EXT3_FEATURE_COMPAT_HAS_JOURNAL |
|
2004-12-15 22:39:16 +03:00
|
|
|
EXT2_FEATURE_COMPAT_RESIZE_INODE |
|
2006-05-09 04:17:26 +04:00
|
|
|
EXT2_FEATURE_COMPAT_DIR_INDEX |
|
2014-01-12 07:11:42 +04:00
|
|
|
EXT2_FEATURE_COMPAT_EXT_ATTR |
|
|
|
|
EXT4_FEATURE_COMPAT_SPARSE_SUPER2,
|
2008-02-27 23:01:19 +03:00
|
|
|
/* Incompat */
|
|
|
|
EXT2_FEATURE_INCOMPAT_FILETYPE|
|
2008-02-20 16:13:19 +03:00
|
|
|
EXT3_FEATURE_INCOMPAT_EXTENTS|
|
2002-10-20 08:38:57 +04:00
|
|
|
EXT3_FEATURE_INCOMPAT_JOURNAL_DEV|
|
2007-08-14 08:32:57 +04:00
|
|
|
EXT2_FEATURE_INCOMPAT_META_BG|
|
2010-06-13 21:00:00 +04:00
|
|
|
EXT4_FEATURE_INCOMPAT_FLEX_BG|
|
2011-09-24 21:48:55 +04:00
|
|
|
EXT4_FEATURE_INCOMPAT_MMP |
|
2010-06-13 21:00:00 +04:00
|
|
|
EXT4_FEATURE_INCOMPAT_64BIT,
|
2008-02-27 23:01:19 +03:00
|
|
|
/* R/O compat */
|
|
|
|
EXT2_FEATURE_RO_COMPAT_LARGE_FILE|
|
2008-07-10 18:49:59 +04:00
|
|
|
EXT4_FEATURE_RO_COMPAT_HUGE_FILE|
|
|
|
|
EXT4_FEATURE_RO_COMPAT_DIR_NLINK|
|
|
|
|
EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE|
|
2007-10-22 06:03:36 +04:00
|
|
|
EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER|
|
2011-06-11 02:57:22 +04:00
|
|
|
EXT4_FEATURE_RO_COMPAT_GDT_CSUM|
|
2011-07-20 22:40:04 +04:00
|
|
|
EXT4_FEATURE_RO_COMPAT_BIGALLOC|
|
2011-11-14 19:40:43 +04:00
|
|
|
#ifdef CONFIG_QUOTA
|
|
|
|
EXT4_FEATURE_RO_COMPAT_QUOTA|
|
|
|
|
#endif
|
|
|
|
0
|
1999-10-23 05:04:50 +04:00
|
|
|
};
|
1997-04-30 01:26:48 +04:00
|
|
|
|
|
|
|
|
2006-03-24 06:00:01 +03:00
|
|
|
static void syntax_err_report(const char *filename, long err, int line_num)
|
|
|
|
{
|
2008-08-28 07:07:54 +04:00
|
|
|
fprintf(stderr,
|
2006-03-24 06:00:01 +03:00
|
|
|
_("Syntax error in mke2fs config file (%s, line #%d)\n\t%s\n"),
|
|
|
|
filename, line_num, error_message(err));
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2006-06-10 18:08:18 +04:00
|
|
|
static const char *config_fn[] = { ROOT_SYSCONFDIR "/mke2fs.conf", 0 };
|
2006-03-24 06:00:01 +03:00
|
|
|
|
2008-08-28 07:07:54 +04:00
|
|
|
static void edit_feature(const char *str, __u32 *compat_array)
|
2006-03-24 06:00:01 +03:00
|
|
|
{
|
|
|
|
if (!str)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (e2p_edit_feature(str, compat_array, ok_features)) {
|
2008-08-28 07:07:54 +04:00
|
|
|
fprintf(stderr, _("Invalid filesystem option set: %s\n"),
|
2006-03-24 06:00:01 +03:00
|
|
|
str);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-18 00:56:17 +03:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-19 16:32:58 +03:00
|
|
|
struct str_list {
|
|
|
|
char **list;
|
|
|
|
int num;
|
|
|
|
int max;
|
|
|
|
};
|
|
|
|
|
|
|
|
static errcode_t init_list(struct str_list *sl)
|
|
|
|
{
|
|
|
|
sl->num = 0;
|
|
|
|
sl->max = 0;
|
|
|
|
sl->list = malloc((sl->max+1) * sizeof(char *));
|
|
|
|
if (!sl->list)
|
|
|
|
return ENOMEM;
|
|
|
|
sl->list[0] = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static errcode_t push_string(struct str_list *sl, const char *str)
|
|
|
|
{
|
|
|
|
char **new_list;
|
|
|
|
|
|
|
|
if (sl->num >= sl->max) {
|
|
|
|
sl->max += 2;
|
|
|
|
new_list = realloc(sl->list, (sl->max+1) * sizeof(char *));
|
|
|
|
if (!new_list)
|
|
|
|
return ENOMEM;
|
|
|
|
sl->list = new_list;
|
|
|
|
}
|
|
|
|
sl->list[sl->num] = malloc(strlen(str)+1);
|
|
|
|
if (sl->list[sl->num] == 0)
|
|
|
|
return ENOMEM;
|
|
|
|
strcpy(sl->list[sl->num], str);
|
|
|
|
sl->num++;
|
|
|
|
sl->list[sl->num] = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void print_str_list(char **list)
|
|
|
|
{
|
|
|
|
char **cpp;
|
|
|
|
|
|
|
|
for (cpp = list; *cpp; cpp++) {
|
|
|
|
printf("'%s'", *cpp);
|
|
|
|
if (cpp[1])
|
|
|
|
fputs(", ", stdout);
|
|
|
|
}
|
|
|
|
fputc('\n', stdout);
|
|
|
|
}
|
|
|
|
|
2010-12-02 02:28:35 +03:00
|
|
|
/*
|
|
|
|
* Return TRUE if the profile has the given subsection
|
|
|
|
*/
|
2013-05-20 04:03:48 +04:00
|
|
|
static int profile_has_subsection(profile_t prof, const char *section,
|
2010-12-02 02:28:35 +03:00
|
|
|
const char *subsection)
|
|
|
|
{
|
|
|
|
void *state;
|
|
|
|
const char *names[4];
|
|
|
|
char *name;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
names[0] = section;
|
|
|
|
names[1] = subsection;
|
|
|
|
names[2] = 0;
|
|
|
|
|
2013-05-20 04:03:48 +04:00
|
|
|
if (profile_iterator_create(prof, names,
|
2010-12-02 02:28:35 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2008-02-19 16:32:58 +03:00
|
|
|
static char **parse_fs_type(const char *fs_type,
|
|
|
|
const char *usage_types,
|
2013-05-20 04:03:48 +04:00
|
|
|
struct ext2_super_block *sb,
|
2010-06-13 22:00:00 +04:00
|
|
|
blk64_t fs_blocks_count,
|
2008-02-19 16:32:58 +03:00
|
|
|
char *progname)
|
|
|
|
{
|
|
|
|
const char *ext_type = 0;
|
|
|
|
char *parse_str;
|
|
|
|
char *profile_type = 0;
|
|
|
|
char *cp, *t;
|
|
|
|
const char *size_type;
|
|
|
|
struct str_list list;
|
2010-06-13 22:00:00 +04:00
|
|
|
unsigned long long meg;
|
2008-07-10 17:24:25 +04:00
|
|
|
int is_hurd = 0;
|
2008-02-19 16:32:58 +03:00
|
|
|
|
|
|
|
if (init_list(&list))
|
|
|
|
return 0;
|
|
|
|
|
2008-07-10 17:24:25 +04:00
|
|
|
if (creator_os && (!strcasecmp(creator_os, "GNU") ||
|
|
|
|
!strcasecmp(creator_os, "hurd")))
|
|
|
|
is_hurd = 1;
|
|
|
|
|
2008-02-19 16:32:58 +03:00
|
|
|
if (fs_type)
|
|
|
|
ext_type = fs_type;
|
2008-07-10 17:24:25 +04:00
|
|
|
else if (is_hurd)
|
|
|
|
ext_type = "ext2";
|
2009-01-20 20:02:40 +03:00
|
|
|
else if (!strcmp(program_name, "mke3fs"))
|
|
|
|
ext_type = "ext3";
|
2012-02-16 00:11:35 +04:00
|
|
|
else if (!strcmp(program_name, "mke4fs"))
|
|
|
|
ext_type = "ext4";
|
2008-02-19 16:32:58 +03:00
|
|
|
else if (progname) {
|
|
|
|
ext_type = strrchr(progname, '/');
|
|
|
|
if (ext_type)
|
|
|
|
ext_type++;
|
|
|
|
else
|
|
|
|
ext_type = progname;
|
|
|
|
|
|
|
|
if (!strncmp(ext_type, "mkfs.", 5)) {
|
|
|
|
ext_type += 5;
|
|
|
|
if (ext_type[0] == 0)
|
|
|
|
ext_type = 0;
|
|
|
|
} else
|
|
|
|
ext_type = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ext_type) {
|
|
|
|
profile_get_string(profile, "defaults", "fs_type", 0,
|
|
|
|
"ext2", &profile_type);
|
|
|
|
ext_type = profile_type;
|
|
|
|
if (!strcmp(ext_type, "ext2") && (journal_size != 0))
|
|
|
|
ext_type = "ext3";
|
|
|
|
}
|
|
|
|
|
2010-12-02 02:28:35 +03:00
|
|
|
|
|
|
|
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")) {
|
2013-12-16 07:11:40 +04:00
|
|
|
printf("%s", _("You probably need to install an "
|
|
|
|
"updated mke2fs.conf file.\n\n"));
|
2010-12-02 02:28:35 +03:00
|
|
|
}
|
|
|
|
if (!force) {
|
2013-12-16 07:11:40 +04:00
|
|
|
printf("%s", _("Aborting...\n"));
|
2010-12-02 02:28:35 +03:00
|
|
|
exit(1);
|
2008-08-23 05:57:29 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-20 04:03:48 +04:00
|
|
|
meg = (1024 * 1024) / EXT2_BLOCK_SIZE(sb);
|
2010-06-13 22:00:00 +04:00
|
|
|
if (fs_blocks_count < 3 * meg)
|
2008-02-19 16:32:58 +03:00
|
|
|
size_type = "floppy";
|
2010-06-13 22:00:00 +04:00
|
|
|
else if (fs_blocks_count < 512 * meg)
|
2008-02-19 16:32:58 +03:00
|
|
|
size_type = "small";
|
2010-11-29 11:55:13 +03:00
|
|
|
else if (fs_blocks_count < 4 * 1024 * 1024 * meg)
|
|
|
|
size_type = "default";
|
|
|
|
else if (fs_blocks_count < 16 * 1024 * 1024 * meg)
|
2010-06-13 22:00:00 +04:00
|
|
|
size_type = "big";
|
2008-02-19 16:32:58 +03:00
|
|
|
else
|
2010-11-29 11:55:13 +03:00
|
|
|
size_type = "huge";
|
2008-02-19 16:32:58 +03:00
|
|
|
|
|
|
|
if (!usage_types)
|
|
|
|
usage_types = size_type;
|
|
|
|
|
2011-09-17 00:49:19 +04:00
|
|
|
parse_str = malloc(strlen(usage_types)+1);
|
2008-02-19 16:32:58 +03:00
|
|
|
if (!parse_str) {
|
2013-12-12 22:06:44 +04:00
|
|
|
free(profile_type);
|
2008-02-19 16:32:58 +03:00
|
|
|
free(list.list);
|
|
|
|
return 0;
|
|
|
|
}
|
2011-09-17 00:49:19 +04:00
|
|
|
strcpy(parse_str, usage_types);
|
2008-02-19 16:32:58 +03:00
|
|
|
|
|
|
|
if (ext_type)
|
|
|
|
push_string(&list, ext_type);
|
|
|
|
cp = parse_str;
|
|
|
|
while (1) {
|
|
|
|
t = strchr(cp, ',');
|
|
|
|
if (t)
|
|
|
|
*t = '\0';
|
|
|
|
|
2010-12-02 02:28:35 +03:00
|
|
|
if (*cp) {
|
2010-12-23 02:31:36 +03:00
|
|
|
if (profile_has_subsection(profile, "fs_types", cp))
|
|
|
|
push_string(&list, cp);
|
|
|
|
else if (strcmp(cp, "default") != 0)
|
2010-12-02 02:28:35 +03:00
|
|
|
fprintf(stderr,
|
|
|
|
_("\nWarning: the fs_type %s is not "
|
2010-12-23 02:31:36 +03:00
|
|
|
"defined in mke2fs.conf\n\n"),
|
2010-12-02 02:28:35 +03:00
|
|
|
cp);
|
|
|
|
}
|
2008-02-19 16:32:58 +03:00
|
|
|
if (t)
|
|
|
|
cp = t+1;
|
2013-05-20 04:03:48 +04:00
|
|
|
else
|
2008-02-19 16:32:58 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
free(parse_str);
|
2009-02-23 20:07:50 +03:00
|
|
|
free(profile_type);
|
2008-07-10 17:24:25 +04:00
|
|
|
if (is_hurd)
|
|
|
|
push_string(&list, "hurd");
|
2008-02-19 16:32:58 +03:00
|
|
|
return (list.list);
|
|
|
|
}
|
|
|
|
|
2014-01-21 08:06:07 +04:00
|
|
|
char *get_string_from_profile(char **types, const char *opt,
|
2008-02-19 16:32:58 +03:00
|
|
|
const char *def_val)
|
|
|
|
{
|
|
|
|
char *ret = 0;
|
|
|
|
int i;
|
|
|
|
|
2013-05-20 04:03:48 +04:00
|
|
|
for (i=0; types[i]; i++);
|
2008-02-19 16:32:58 +03:00
|
|
|
for (i-=1; i >=0 ; i--) {
|
2013-05-20 04:03:48 +04:00
|
|
|
profile_get_string(profile, "fs_types", types[i],
|
2008-02-19 16:32:58 +03:00
|
|
|
opt, 0, &ret);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
profile_get_string(profile, "defaults", opt, 0, def_val, &ret);
|
|
|
|
return (ret);
|
|
|
|
}
|
|
|
|
|
2014-01-21 08:06:07 +04:00
|
|
|
int get_int_from_profile(char **types, const char *opt, int def_val)
|
2008-02-19 16:32:58 +03:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
char **cpp;
|
|
|
|
|
|
|
|
profile_get_integer(profile, "defaults", opt, 0, def_val, &ret);
|
2013-05-20 04:03:48 +04:00
|
|
|
for (cpp = types; *cpp; cpp++)
|
2008-02-19 16:32:58 +03:00
|
|
|
profile_get_integer(profile, "fs_types", *cpp, opt, ret, &ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-05-20 04:03:48 +04:00
|
|
|
static double get_double_from_profile(char **types, const char *opt,
|
2011-05-11 01:51:31 +04:00
|
|
|
double def_val)
|
|
|
|
{
|
|
|
|
double ret;
|
|
|
|
char **cpp;
|
|
|
|
|
|
|
|
profile_get_double(profile, "defaults", opt, 0, def_val, &ret);
|
2013-05-20 04:03:48 +04:00
|
|
|
for (cpp = types; *cpp; cpp++)
|
2011-05-11 01:51:31 +04:00
|
|
|
profile_get_double(profile, "fs_types", *cpp, opt, ret, &ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-01-21 08:06:07 +04:00
|
|
|
int get_bool_from_profile(char **types, const char *opt, int def_val)
|
2008-04-18 18:19:27 +04:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
char **cpp;
|
|
|
|
|
|
|
|
profile_get_boolean(profile, "defaults", opt, 0, def_val, &ret);
|
2013-05-20 04:03:48 +04:00
|
|
|
for (cpp = types; *cpp; cpp++)
|
2008-04-18 18:19:27 +04:00
|
|
|
profile_get_boolean(profile, "fs_types", *cpp, opt, ret, &ret);
|
|
|
|
return ret;
|
|
|
|
}
|
2008-02-19 16:32:58 +03:00
|
|
|
|
2007-07-04 22:10:46 +04:00
|
|
|
extern const char *mke2fs_default_profile;
|
|
|
|
static const char *default_files[] = { "<default>", 0 };
|
|
|
|
|
2009-10-02 20:32:42 +04:00
|
|
|
#ifdef HAVE_BLKID_PROBE_GET_TOPOLOGY
|
|
|
|
/*
|
|
|
|
* Sets the geometry of a device (stripe/stride), and returns the
|
|
|
|
* device's alignment offset, if any, or a negative error.
|
|
|
|
*/
|
2010-11-22 18:50:42 +03:00
|
|
|
static int get_device_geometry(const char *file,
|
|
|
|
struct ext2_super_block *fs_param,
|
|
|
|
int psector_size)
|
2009-10-02 20:32:42 +04:00
|
|
|
{
|
|
|
|
int rc = -1;
|
|
|
|
int blocksize;
|
|
|
|
blkid_probe pr;
|
|
|
|
blkid_topology tp;
|
|
|
|
unsigned long min_io;
|
|
|
|
unsigned long opt_io;
|
2010-01-24 06:50:45 +03:00
|
|
|
struct stat statbuf;
|
|
|
|
|
|
|
|
/* Nothing to do for a regular file */
|
|
|
|
if (!stat(file, &statbuf) && S_ISREG(statbuf.st_mode))
|
|
|
|
return 0;
|
2009-10-02 20:32:42 +04:00
|
|
|
|
|
|
|
pr = blkid_new_probe_from_filename(file);
|
|
|
|
if (!pr)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
tp = blkid_probe_get_topology(pr);
|
|
|
|
if (!tp)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
min_io = blkid_topology_get_minimum_io_size(tp);
|
|
|
|
opt_io = blkid_topology_get_optimal_io_size(tp);
|
|
|
|
blocksize = EXT2_BLOCK_SIZE(fs_param);
|
2010-11-22 18:50:42 +03:00
|
|
|
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;
|
2009-10-02 20:32:42 +04:00
|
|
|
|
2011-04-04 23:11:52 +04:00
|
|
|
/* 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;
|
2009-10-02 20:32:42 +04:00
|
|
|
|
|
|
|
rc = blkid_topology_get_alignment_offset(tp);
|
|
|
|
out:
|
|
|
|
blkid_free_probe(pr);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
static void PRS(int argc, char *argv[])
|
|
|
|
{
|
2014-04-27 02:42:31 +04:00
|
|
|
int b, c, flags;
|
2011-06-14 22:30:22 +04:00
|
|
|
int cluster_size = 0;
|
2008-07-07 02:36:56 +04:00
|
|
|
char *tmp, **cpp;
|
1999-10-26 18:35:51 +04:00
|
|
|
int blocksize = 0;
|
|
|
|
int inode_ratio = 0;
|
2002-05-16 13:20:07 +04:00
|
|
|
int inode_size = 0;
|
2008-04-22 16:27:01 +04:00
|
|
|
unsigned long flex_bg_size = 0;
|
2011-05-11 01:51:31 +04:00
|
|
|
double reserved_ratio = -1.0;
|
2010-05-18 06:31:45 +04:00
|
|
|
int lsector_size = 0, psector_size = 0;
|
2014-04-26 23:12:21 +04:00
|
|
|
int show_version_only = 0, is_device = 0;
|
2007-05-25 19:18:11 +04:00
|
|
|
unsigned long long num_inodes = 0; /* unsigned long long to catch too-large input */
|
1997-04-26 18:00:26 +04:00
|
|
|
errcode_t retval;
|
1999-10-26 18:35:51 +04:00
|
|
|
char * oldpath = getenv("PATH");
|
2005-01-05 19:12:20 +03:00
|
|
|
char * extended_opts = 0;
|
2011-06-14 22:17:56 +04:00
|
|
|
char * fs_type = 0;
|
|
|
|
char * usage_types = 0;
|
2013-12-11 05:18:37 +04:00
|
|
|
/*
|
|
|
|
* NOTE: A few words about fs_blocks_count and blocksize:
|
|
|
|
*
|
|
|
|
* Initially, blocksize is set to zero, which implies 1024.
|
|
|
|
* If -b is specified, blocksize is updated to the user's value.
|
|
|
|
*
|
|
|
|
* Next, the device size or the user's "blocks" command line argument
|
|
|
|
* is used to set fs_blocks_count; the units are blocksize.
|
|
|
|
*
|
|
|
|
* Later, if blocksize hasn't been set and the profile specifies a
|
|
|
|
* blocksize, then blocksize is updated and fs_blocks_count is scaled
|
|
|
|
* appropriately. Note the change in units!
|
|
|
|
*
|
|
|
|
* Finally, we complain about fs_blocks_count > 2^32 on a non-64bit fs.
|
|
|
|
*/
|
2010-06-13 22:00:00 +04:00
|
|
|
blk64_t fs_blocks_count = 0;
|
2002-05-17 18:53:07 +04:00
|
|
|
long sysval;
|
2006-03-24 06:00:01 +03:00
|
|
|
int s_opt = -1, r_opt = -1;
|
|
|
|
char *fs_features = 0;
|
|
|
|
int use_bsize;
|
2006-11-15 07:38:17 +03:00
|
|
|
char *newpath;
|
|
|
|
int pathlen = sizeof(PATH_SET) + 1;
|
|
|
|
|
|
|
|
if (oldpath)
|
|
|
|
pathlen += strlen(oldpath);
|
|
|
|
newpath = malloc(pathlen);
|
2010-12-16 12:40:40 +03:00
|
|
|
if (!newpath) {
|
2013-12-16 07:11:40 +04:00
|
|
|
fprintf(stderr, "%s",
|
|
|
|
_("Couldn't allocate memory for new PATH.\n"));
|
2010-12-16 12:40:40 +03:00
|
|
|
exit(1);
|
|
|
|
}
|
2006-11-15 07:38:17 +03:00
|
|
|
strcpy(newpath, PATH_SET);
|
2001-05-14 02:58:27 +04:00
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
/* Update our PATH to include /sbin */
|
1997-04-26 18:00:26 +04:00
|
|
|
if (oldpath) {
|
|
|
|
strcat (newpath, ":");
|
|
|
|
strcat (newpath, oldpath);
|
2006-11-15 07:38:17 +03:00
|
|
|
}
|
|
|
|
putenv (newpath);
|
1997-04-26 17:21:57 +04:00
|
|
|
|
2001-01-16 10:47:31 +03:00
|
|
|
tmp = getenv("MKE2FS_SYNC");
|
|
|
|
if (tmp)
|
|
|
|
sync_kludge = atoi(tmp);
|
2002-05-17 18:53:07 +04:00
|
|
|
|
|
|
|
/* Determine the system page size if possible */
|
|
|
|
#ifdef HAVE_SYSCONF
|
|
|
|
#if (!defined(_SC_PAGESIZE) && defined(_SC_PAGE_SIZE))
|
|
|
|
#define _SC_PAGESIZE _SC_PAGE_SIZE
|
|
|
|
#endif
|
|
|
|
#ifdef _SC_PAGESIZE
|
|
|
|
sysval = sysconf(_SC_PAGESIZE);
|
2002-05-18 23:27:33 +04:00
|
|
|
if (sysval > 0)
|
2002-05-17 18:53:07 +04:00
|
|
|
sys_page_size = sysval;
|
|
|
|
#endif /* _SC_PAGESIZE */
|
|
|
|
#endif /* HAVE_SYSCONF */
|
2006-03-24 06:00:01 +03:00
|
|
|
|
|
|
|
if ((tmp = getenv("MKE2FS_CONFIG")) != NULL)
|
|
|
|
config_fn[0] = tmp;
|
|
|
|
profile_set_syntax_err_cb(syntax_err_report);
|
2007-07-04 22:10:46 +04:00
|
|
|
retval = profile_init(config_fn, &profile);
|
|
|
|
if (retval == ENOENT) {
|
2010-12-16 12:40:40 +03:00
|
|
|
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);
|
2007-07-04 22:10:46 +04:00
|
|
|
}
|
2008-08-28 07:07:54 +04:00
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
setbuf(stdout, NULL);
|
|
|
|
setbuf(stderr, NULL);
|
2006-12-26 11:38:07 +03:00
|
|
|
add_error_table(&et_ext2_error_table);
|
|
|
|
add_error_table(&et_prof_error_table);
|
2005-12-11 05:50:30 +03:00
|
|
|
memset(&fs_param, 0, sizeof(struct ext2_super_block));
|
|
|
|
fs_param.s_rev_level = 1; /* Create revision 1 filesystems now */
|
2002-09-22 23:37:40 +04:00
|
|
|
|
2014-07-06 05:07:55 +04:00
|
|
|
if (is_before_linux_ver(2, 2, 0))
|
2005-12-11 05:50:30 +03:00
|
|
|
fs_param.s_rev_level = 0;
|
2002-02-26 09:11:26 +03:00
|
|
|
|
|
|
|
if (argc && *argv) {
|
|
|
|
program_name = get_progname(*argv);
|
|
|
|
|
|
|
|
/* If called as mkfs.ext3, create a journal inode */
|
2009-01-20 20:02:40 +03:00
|
|
|
if (!strcmp(program_name, "mkfs.ext3") ||
|
|
|
|
!strcmp(program_name, "mke3fs"))
|
2002-02-26 09:11:26 +03:00
|
|
|
journal_size = -1;
|
|
|
|
}
|
|
|
|
|
1997-04-29 18:53:37 +04:00
|
|
|
while ((c = getopt (argc, argv,
|
2012-03-23 00:00:49 +04:00
|
|
|
"b:cg:i:jl:m:no:qr:s:t:vC:DE:FG:I:J:KL:M:N:O:R:ST:U:V")) != EOF) {
|
1997-04-26 17:21:57 +04:00
|
|
|
switch (c) {
|
|
|
|
case 'b':
|
2013-01-15 04:03:11 +04:00
|
|
|
blocksize = parse_num_blocks2(optarg, -1);
|
2003-04-12 06:10:50 +04:00
|
|
|
b = (blocksize > 0) ? blocksize : -blocksize;
|
|
|
|
if (b < EXT2_MIN_BLOCK_SIZE ||
|
2013-01-15 04:03:11 +04:00
|
|
|
b > EXT2_MAX_BLOCK_SIZE) {
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
com_err(program_name, 0,
|
2005-05-06 07:15:55 +04:00
|
|
|
_("invalid block size - %s"), optarg);
|
1997-04-26 17:21:57 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
2002-05-16 13:20:07 +04:00
|
|
|
if (blocksize > 4096)
|
|
|
|
fprintf(stderr, _("Warning: blocksize %d not "
|
|
|
|
"usable on most systems.\n"),
|
|
|
|
blocksize);
|
2008-08-28 07:07:54 +04:00
|
|
|
if (blocksize > 0)
|
2005-12-11 05:50:30 +03:00
|
|
|
fs_param.s_log_block_size =
|
2003-04-12 06:10:50 +04:00
|
|
|
int_log2(blocksize >>
|
|
|
|
EXT2_MIN_BLOCK_LOG_SIZE);
|
1997-04-26 17:21:57 +04:00
|
|
|
break;
|
2001-04-22 07:47:23 +04:00
|
|
|
case 'c': /* Check for bad blocks */
|
2001-12-24 23:01:59 +03:00
|
|
|
cflag++;
|
1997-04-26 17:21:57 +04:00
|
|
|
break;
|
2011-06-11 02:57:22 +04:00
|
|
|
case 'C':
|
2013-01-15 04:03:11 +04:00
|
|
|
cluster_size = parse_num_blocks2(optarg, -1);
|
2013-01-15 02:28:00 +04:00
|
|
|
if (cluster_size <= EXT2_MIN_CLUSTER_SIZE ||
|
2013-01-15 04:03:11 +04:00
|
|
|
cluster_size > EXT2_MAX_CLUSTER_SIZE) {
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
com_err(program_name, 0,
|
2011-10-05 02:12:11 +04:00
|
|
|
_("invalid cluster size - %s"),
|
1997-04-26 17:21:57 +04:00
|
|
|
optarg);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
break;
|
2012-03-23 00:00:49 +04:00
|
|
|
case 'D':
|
|
|
|
direct_io = 1;
|
|
|
|
break;
|
2013-06-16 02:47:30 +04:00
|
|
|
case 'R':
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, 0, "%s",
|
2013-06-16 02:47:30 +04:00
|
|
|
_("'-R' is deprecated, use '-E' instead"));
|
|
|
|
/* fallthrough */
|
|
|
|
case 'E':
|
|
|
|
extended_opts = optarg;
|
|
|
|
break;
|
|
|
|
case 'F':
|
|
|
|
force++;
|
|
|
|
break;
|
1997-04-26 17:21:57 +04:00
|
|
|
case 'g':
|
2005-12-11 05:50:30 +03:00
|
|
|
fs_param.s_blocks_per_group = strtoul(optarg, &tmp, 0);
|
1997-04-26 17:34:30 +04:00
|
|
|
if (*tmp) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, 0, "%s",
|
|
|
|
_("Illegal number for blocks per group"));
|
1997-04-26 17:34:30 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
2005-12-11 05:50:30 +03:00
|
|
|
if ((fs_param.s_blocks_per_group % 8) != 0) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, 0, "%s",
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
_("blocks per group must be multiple of 8"));
|
1997-04-26 17:21:57 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
break;
|
2008-04-22 16:27:01 +04:00
|
|
|
case 'G':
|
|
|
|
flex_bg_size = strtoul(optarg, &tmp, 0);
|
|
|
|
if (*tmp) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, 0, "%s",
|
2008-04-22 16:27:01 +04:00
|
|
|
_("Illegal number for flex_bg size"));
|
|
|
|
exit(1);
|
|
|
|
}
|
2010-05-11 05:49:58 +04:00
|
|
|
if (flex_bg_size < 1 ||
|
2008-04-22 16:27:01 +04:00
|
|
|
(flex_bg_size & (flex_bg_size-1)) != 0) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, 0, "%s",
|
2008-04-22 16:27:01 +04:00
|
|
|
_("flex_bg size must be a power of 2"));
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
break;
|
1997-04-26 17:21:57 +04:00
|
|
|
case 'i':
|
|
|
|
inode_ratio = strtoul(optarg, &tmp, 0);
|
2002-05-16 13:20:07 +04:00
|
|
|
if (inode_ratio < EXT2_MIN_BLOCK_SIZE ||
|
|
|
|
inode_ratio > EXT2_MAX_BLOCK_SIZE * 1024 ||
|
1997-04-26 17:21:57 +04:00
|
|
|
*tmp) {
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
com_err(program_name, 0,
|
2005-06-20 16:35:27 +04:00
|
|
|
_("invalid inode ratio %s (min %d/max %d)"),
|
2002-05-16 13:20:07 +04:00
|
|
|
optarg, EXT2_MIN_BLOCK_SIZE,
|
2010-07-31 04:43:11 +04:00
|
|
|
EXT2_MAX_BLOCK_SIZE * 1024);
|
1997-04-26 17:21:57 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
break;
|
2013-06-16 02:47:30 +04:00
|
|
|
case 'I':
|
|
|
|
inode_size = strtoul(optarg, &tmp, 0);
|
|
|
|
if (*tmp) {
|
|
|
|
com_err(program_name, 0,
|
|
|
|
_("invalid inode size - %s"), optarg);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'j':
|
|
|
|
if (!journal_size)
|
|
|
|
journal_size = -1;
|
|
|
|
break;
|
ChangeLog, mke2fs.8.in, mke2fs.c, tune2fs.8.in, tune2fs.c:
tune2fs.c, mke2fs.c, tune2fs.8.in, mke2fs.8.in: Change user interface
so that -J is used to specify journal options, and -j is used to
request creation of a journal using default values. (This is a UI
change, but we haven't done a formal release, and it makes things much
more consistent with the rest of the options out there.)
tune2fs.c: Add support for removing a filesystem from an external
journal; we correctly remove the filesystem UUID from the external
journal's filesystem list.
2001-01-18 04:51:15 +03:00
|
|
|
case 'J':
|
|
|
|
parse_journal_opts(optarg);
|
|
|
|
break;
|
2009-10-08 01:49:17 +04:00
|
|
|
case 'K':
|
2013-12-16 07:11:40 +04:00
|
|
|
fprintf(stderr, "%s",
|
|
|
|
_("Warning: -K option is deprecated and "
|
|
|
|
"should not be used anymore. Use "
|
|
|
|
"\'-E nodiscard\' extended option "
|
|
|
|
"instead!\n"));
|
2009-10-08 01:49:17 +04:00
|
|
|
discard = 0;
|
|
|
|
break;
|
1997-04-26 17:21:57 +04:00
|
|
|
case 'l':
|
2013-12-12 22:06:44 +04:00
|
|
|
bad_blocks_filename = realloc(bad_blocks_filename,
|
|
|
|
strlen(optarg) + 1);
|
1997-04-26 17:34:30 +04:00
|
|
|
if (!bad_blocks_filename) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, ENOMEM, "%s",
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
_("in malloc for bad_blocks_filename"));
|
1997-04-26 17:34:30 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
strcpy(bad_blocks_filename, optarg);
|
1997-04-26 17:21:57 +04:00
|
|
|
break;
|
2013-06-16 02:47:30 +04:00
|
|
|
case 'L':
|
|
|
|
volume_label = optarg;
|
|
|
|
break;
|
1997-04-26 17:21:57 +04:00
|
|
|
case 'm':
|
2005-07-06 20:50:08 +04:00
|
|
|
reserved_ratio = strtod(optarg, &tmp);
|
2009-03-06 10:23:59 +03:00
|
|
|
if ( *tmp || reserved_ratio > 50 ||
|
|
|
|
reserved_ratio < 0) {
|
1997-04-26 17:21:57 +04:00
|
|
|
com_err(program_name, 0,
|
2005-06-20 16:35:27 +04:00
|
|
|
_("invalid reserved blocks percent - %s"),
|
1997-04-26 17:21:57 +04:00
|
|
|
optarg);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
break;
|
2013-06-16 02:47:30 +04:00
|
|
|
case 'M':
|
|
|
|
mount_dir = optarg;
|
|
|
|
break;
|
1999-07-19 19:30:21 +04:00
|
|
|
case 'n':
|
|
|
|
noaction++;
|
|
|
|
break;
|
2013-06-16 02:47:30 +04:00
|
|
|
case 'N':
|
|
|
|
num_inodes = strtoul(optarg, &tmp, 0);
|
|
|
|
if (*tmp) {
|
|
|
|
com_err(program_name, 0,
|
|
|
|
_("bad num inodes - %s"), optarg);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
break;
|
1997-04-29 18:53:37 +04:00
|
|
|
case 'o':
|
|
|
|
creator_os = optarg;
|
|
|
|
break;
|
2013-06-16 02:47:30 +04:00
|
|
|
case 'O':
|
|
|
|
fs_features = optarg;
|
|
|
|
break;
|
2005-07-06 21:58:15 +04:00
|
|
|
case 'q':
|
|
|
|
quiet = 1;
|
|
|
|
break;
|
1997-04-26 18:48:50 +04:00
|
|
|
case 'r':
|
2006-03-24 06:00:01 +03:00
|
|
|
r_opt = strtoul(optarg, &tmp, 0);
|
2005-07-06 21:58:15 +04:00
|
|
|
if (*tmp) {
|
|
|
|
com_err(program_name, 0,
|
|
|
|
_("bad revision level - %s"), optarg);
|
|
|
|
exit(1);
|
|
|
|
}
|
2014-07-04 23:31:50 +04:00
|
|
|
if (r_opt > EXT2_MAX_SUPP_REV) {
|
|
|
|
com_err(program_name, EXT2_ET_REV_TOO_HIGH,
|
|
|
|
_("while trying to create revision %d"), r_opt);
|
|
|
|
exit(1);
|
|
|
|
}
|
2006-03-24 06:00:01 +03:00
|
|
|
fs_param.s_rev_level = r_opt;
|
1997-04-26 18:48:50 +04:00
|
|
|
break;
|
2001-04-22 07:47:23 +04:00
|
|
|
case 's': /* deprecated */
|
2006-03-24 06:00:01 +03:00
|
|
|
s_opt = atoi(optarg);
|
1997-04-29 21:48:10 +04:00
|
|
|
break;
|
1997-04-26 17:34:30 +04:00
|
|
|
case 'S':
|
|
|
|
super_only = 1;
|
|
|
|
break;
|
2008-02-19 16:32:58 +03:00
|
|
|
case 't':
|
2011-09-17 00:49:32 +04:00
|
|
|
if (fs_type) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, 0, "%s",
|
2011-09-17 00:49:32 +04:00
|
|
|
_("The -t option may only be used once"));
|
|
|
|
exit(1);
|
|
|
|
}
|
2011-06-14 22:17:56 +04:00
|
|
|
fs_type = strdup(optarg);
|
1999-07-19 19:30:21 +04:00
|
|
|
break;
|
2008-02-19 16:32:58 +03:00
|
|
|
case 'T':
|
2011-09-17 00:49:32 +04:00
|
|
|
if (usage_types) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, 0, "%s",
|
2011-09-17 00:49:32 +04:00
|
|
|
_("The -T option may only be used once"));
|
|
|
|
exit(1);
|
|
|
|
}
|
2011-06-14 22:17:56 +04:00
|
|
|
usage_types = strdup(optarg);
|
2008-02-19 16:32:58 +03:00
|
|
|
break;
|
2009-01-20 21:18:23 +03:00
|
|
|
case 'U':
|
|
|
|
fs_uuid = optarg;
|
|
|
|
break;
|
2013-06-16 02:47:30 +04:00
|
|
|
case 'v':
|
|
|
|
verbose = 1;
|
|
|
|
break;
|
ChangeLog, debugfs.8.in, debugfs.c:
Add a -V option which displays the current version.
ChangeLog, unix.c:
unix.c (e2fsck_update_progress): Remove unused variables.
ChangeLog, inode.c:
inode.c (get_next_blockgroup): Fix bug where if get_next_blockgroup()
is called early because of a missing inode table in a block group, the
current_inode counter wasn't incremented correctly.
ChangeLog, tst_uuid.c:
tst_uuid.c (main): Fixed bogus declaration of the main's argv parameter.
ChangeLog, test_icount.c:
test_icount.c (main): Fix main() declaration so that it returns int,
not void.
Many files:
fsck.c (ignore): Remove unused variable cp.
chattr.c (fatal_error):
tune2fs.c (usage):
lsattr.c (usage):
dumpe2fs.c (usage):
badblocks.c (usage): Remove volatile from declaration.
fsck.c: Change use of strdup to be string_copy, since we don't trust
what glibc is doing with strdup. (Whatever it is, it isn't pretty.)
1998-06-27 09:11:14 +04:00
|
|
|
case 'V':
|
|
|
|
/* Print version number and exit */
|
2003-12-07 10:28:24 +03:00
|
|
|
show_version_only++;
|
|
|
|
break;
|
1997-04-26 17:21:57 +04:00
|
|
|
default:
|
|
|
|
usage();
|
|
|
|
}
|
|
|
|
}
|
2005-01-05 11:01:06 +03:00
|
|
|
if ((optind == argc) && !show_version_only)
|
1997-04-26 17:21:57 +04:00
|
|
|
usage();
|
2005-01-05 11:01:06 +03:00
|
|
|
device_name = argv[optind++];
|
1997-04-26 18:00:26 +04:00
|
|
|
|
2003-12-07 10:28:24 +03:00
|
|
|
if (!quiet || show_version_only)
|
2008-08-28 07:07:54 +04:00
|
|
|
fprintf (stderr, "mke2fs %s (%s)\n", E2FSPROGS_VERSION,
|
2003-04-16 23:29:39 +04:00
|
|
|
E2FSPROGS_DATE);
|
|
|
|
|
2003-12-07 10:28:24 +03:00
|
|
|
if (show_version_only) {
|
2008-08-28 07:07:54 +04:00
|
|
|
fprintf(stderr, _("\tUsing %s\n"),
|
2003-12-07 10:28:24 +03:00
|
|
|
error_message(EXT2_ET_BASE));
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
|
2001-07-28 06:00:18 +04:00
|
|
|
/*
|
|
|
|
* If there's no blocksize specified and there is a journal
|
|
|
|
* device, use it to figure out the blocksize
|
|
|
|
*/
|
2003-04-12 06:10:50 +04:00
|
|
|
if (blocksize <= 0 && journal_device) {
|
2001-07-28 06:00:18 +04:00
|
|
|
ext2_filsys jfs;
|
2003-07-09 02:03:48 +04:00
|
|
|
io_manager io_ptr;
|
2001-07-28 06:00:18 +04:00
|
|
|
|
2003-07-09 02:03:48 +04:00
|
|
|
#ifdef CONFIG_TESTIO_DEBUG
|
2008-09-01 19:17:29 +04:00
|
|
|
if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_BLOCK")) {
|
|
|
|
io_ptr = test_io_manager;
|
|
|
|
test_io_backing_manager = unix_io_manager;
|
|
|
|
} else
|
2003-07-09 02:03:48 +04:00
|
|
|
#endif
|
2008-09-01 19:17:29 +04:00
|
|
|
io_ptr = unix_io_manager;
|
2001-07-28 06:00:18 +04:00
|
|
|
retval = ext2fs_open(journal_device,
|
|
|
|
EXT2_FLAG_JOURNAL_DEV_OK, 0,
|
2003-07-09 02:03:48 +04:00
|
|
|
0, io_ptr, &jfs);
|
2001-07-28 06:00:18 +04:00
|
|
|
if (retval) {
|
|
|
|
com_err(program_name, retval,
|
|
|
|
_("while trying to open journal device %s\n"),
|
|
|
|
journal_device);
|
|
|
|
exit(1);
|
|
|
|
}
|
2003-12-07 09:28:50 +03:00
|
|
|
if ((blocksize < 0) && (jfs->blocksize < (unsigned) (-blocksize))) {
|
2003-04-12 06:10:50 +04:00
|
|
|
com_err(program_name, 0,
|
2003-05-04 02:45:55 +04:00
|
|
|
_("Journal dev blocksize (%d) smaller than "
|
2003-04-12 06:10:50 +04:00
|
|
|
"minimum blocksize %d\n"), jfs->blocksize,
|
|
|
|
-blocksize);
|
|
|
|
exit(1);
|
|
|
|
}
|
2001-07-28 06:00:18 +04:00
|
|
|
blocksize = jfs->blocksize;
|
2008-07-07 04:57:17 +04:00
|
|
|
printf(_("Using journal device's blocksize: %d\n"), blocksize);
|
2005-12-11 05:50:30 +03:00
|
|
|
fs_param.s_log_block_size =
|
2001-07-28 06:00:18 +04:00
|
|
|
int_log2(blocksize >> EXT2_MIN_BLOCK_LOG_SIZE);
|
2014-07-06 05:06:29 +04:00
|
|
|
ext2fs_close_free(&jfs);
|
2001-07-28 06:00:18 +04:00
|
|
|
}
|
ChangeLog, mke2fs.8.in, mke2fs.c, tune2fs.8.in, tune2fs.c:
tune2fs.c, mke2fs.c, tune2fs.8.in, mke2fs.8.in: Change user interface
so that -J is used to specify journal options, and -j is used to
request creation of a journal using default values. (This is a UI
change, but we haven't done a formal release, and it makes things much
more consistent with the rest of the options out there.)
tune2fs.c: Add support for removing a filesystem from an external
journal; we correctly remove the filesystem UUID from the external
journal's filesystem list.
2001-01-18 04:51:15 +03:00
|
|
|
|
2005-01-05 11:01:06 +03:00
|
|
|
if (optind < argc) {
|
2010-06-13 22:00:00 +04:00
|
|
|
fs_blocks_count = parse_num_blocks2(argv[optind++],
|
|
|
|
fs_param.s_log_block_size);
|
|
|
|
if (!fs_blocks_count) {
|
2010-08-12 22:40:44 +04:00
|
|
|
com_err(program_name, 0,
|
2010-09-25 06:40:21 +04:00
|
|
|
_("invalid blocks '%s' on device '%s'"),
|
2010-08-12 22:40:44 +04:00
|
|
|
argv[optind - 1], device_name);
|
2005-01-05 11:01:06 +03:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (optind < argc)
|
|
|
|
usage();
|
|
|
|
|
2014-04-27 01:34:52 +04:00
|
|
|
profile_get_integer(profile, "options", "proceed_delay", 0, 0,
|
|
|
|
&proceed_delay);
|
|
|
|
|
2014-04-27 02:42:31 +04:00
|
|
|
/* The isatty() test is so we don't break existing scripts */
|
|
|
|
flags = CREATE_FILE;
|
|
|
|
if (isatty(0) && isatty(1))
|
|
|
|
flags |= CHECK_FS_EXIST;
|
2014-05-05 07:40:58 +04:00
|
|
|
if (!quiet)
|
|
|
|
flags |= VERBOSE_CREATE;
|
2014-04-27 02:42:31 +04:00
|
|
|
if (!check_plausibility(device_name, flags, &is_device) && !force)
|
2014-04-27 01:34:52 +04:00
|
|
|
proceed_question(proceed_delay);
|
2014-04-26 21:14:32 +04:00
|
|
|
|
ChangeLog, Makefile.in, mke2fs.c, tune2fs.8.in, tune2fs.c, util.c, util.h:
tune2fs.c (update_feature_set, add_journal): Moved to separate
functions. Added ability to add and remove the journal while the
filesystem is live. Added support for setting a time-based UUID.
Removed zero-initialized static variables.
mke2fs.c, util.c, util.h (strcasecmp, proceed_question,
check_plausibility, parse_journal_opts, check_mount): Moved functions
to util.c so they can be used by tune2fs.
mke2fs.c (main): Change ext2fs_add_journal_fs() to
ext2fs_add_journal_inode() to reflect function renaming.
2001-01-03 20:02:13 +03:00
|
|
|
check_mount(device_name, force, _("filesystem"));
|
1997-04-26 18:00:26 +04:00
|
|
|
|
2010-12-23 02:22:40 +03:00
|
|
|
/* Determine the size of the device (if possible) */
|
2010-06-13 22:00:00 +04:00
|
|
|
if (noaction && fs_blocks_count) {
|
|
|
|
dev_size = fs_blocks_count;
|
1999-07-19 19:30:21 +04:00
|
|
|
retval = 0;
|
2010-06-13 22:00:00 +04:00
|
|
|
} else
|
2010-06-13 21:00:00 +04:00
|
|
|
retval = ext2fs_get_device_size2(device_name,
|
|
|
|
EXT2_BLOCK_SIZE(&fs_param),
|
|
|
|
&dev_size);
|
2008-08-28 07:07:54 +04:00
|
|
|
|
1998-03-30 05:20:55 +04:00
|
|
|
if (retval && (retval != EXT2_ET_UNIMPLEMENTED)) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, retval, "%s",
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
_("while trying to determine filesystem size"));
|
1998-03-30 05:20:55 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
2010-06-13 22:00:00 +04:00
|
|
|
if (!fs_blocks_count) {
|
1998-03-30 05:20:55 +04:00
|
|
|
if (retval == EXT2_ET_UNIMPLEMENTED) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, 0, "%s",
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
_("Couldn't determine device size; you "
|
1998-03-30 05:20:55 +04:00
|
|
|
"must specify\nthe size of the "
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
"filesystem\n"));
|
1997-04-26 18:00:26 +04:00
|
|
|
exit(1);
|
2000-05-29 19:05:42 +04:00
|
|
|
} else {
|
|
|
|
if (dev_size == 0) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, 0, "%s",
|
2000-05-29 19:05:42 +04:00
|
|
|
_("Device size reported to be zero. "
|
|
|
|
"Invalid partition specified, or\n\t"
|
|
|
|
"partition table wasn't reread "
|
|
|
|
"after running fdisk, due to\n\t"
|
|
|
|
"a modified partition being busy "
|
|
|
|
"and in use. You may need to reboot\n\t"
|
|
|
|
"to re-read your partition table.\n"
|
|
|
|
));
|
|
|
|
exit(1);
|
|
|
|
}
|
2010-06-13 22:00:00 +04:00
|
|
|
fs_blocks_count = dev_size;
|
|
|
|
if (sys_page_size > EXT2_BLOCK_SIZE(&fs_param))
|
|
|
|
fs_blocks_count &= ~((blk64_t) ((sys_page_size /
|
2009-09-08 04:46:34 +04:00
|
|
|
EXT2_BLOCK_SIZE(&fs_param))-1));
|
|
|
|
}
|
2014-04-26 23:12:21 +04:00
|
|
|
} else if (!force && is_device && (fs_blocks_count > dev_size)) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, 0, "%s",
|
2003-04-12 06:10:50 +04:00
|
|
|
_("Filesystem larger than apparent device size."));
|
2014-04-27 01:34:52 +04:00
|
|
|
proceed_question(proceed_delay);
|
1997-04-26 18:00:26 +04:00
|
|
|
}
|
1997-04-26 17:21:57 +04:00
|
|
|
|
2011-06-14 22:17:56 +04:00
|
|
|
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);
|
|
|
|
|
2010-12-23 02:22:40 +03:00
|
|
|
/*
|
|
|
|
* 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) {
|
2013-12-16 07:11:40 +04:00
|
|
|
fprintf(stderr, "%s", _("Failed to parse fs types list\n"));
|
2010-12-23 02:22:40 +03:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Figure out what features should be enabled */
|
|
|
|
|
|
|
|
tmp = NULL;
|
|
|
|
if (fs_param.s_rev_level != EXT2_GOOD_OLD_REV) {
|
|
|
|
tmp = get_string_from_profile(fs_types, "base_features",
|
|
|
|
"sparse_super,filetype,resize_inode,dir_index");
|
|
|
|
edit_feature(tmp, &fs_param.s_feature_compat);
|
|
|
|
free(tmp);
|
|
|
|
|
2011-02-18 00:56:17 +03:00
|
|
|
/* 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);
|
|
|
|
|
2010-12-23 02:22:40 +03:00
|
|
|
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);
|
|
|
|
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);
|
|
|
|
if (tmp)
|
|
|
|
free(tmp);
|
|
|
|
|
2013-12-11 05:18:37 +04:00
|
|
|
/* Get the hardware sector sizes, if available */
|
|
|
|
retval = ext2fs_get_device_sectsize(device_name, &lsector_size);
|
|
|
|
if (retval) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, retval, "%s",
|
2013-12-11 05:18:37 +04:00
|
|
|
_("while trying to determine hardware sector size"));
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
retval = ext2fs_get_device_phys_sectsize(device_name, &psector_size);
|
|
|
|
if (retval) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, retval, "%s",
|
2013-12-11 05:18:37 +04:00
|
|
|
_("while trying to determine physical sector size"));
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
tmp = getenv("MKE2FS_DEVICE_SECTSIZE");
|
|
|
|
if (tmp != NULL)
|
|
|
|
lsector_size = atoi(tmp);
|
|
|
|
tmp = getenv("MKE2FS_DEVICE_PHYS_SECTSIZE");
|
|
|
|
if (tmp != 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);
|
|
|
|
|
|
|
|
if (use_bsize == -1) {
|
|
|
|
use_bsize = sys_page_size;
|
2014-07-06 05:07:55 +04:00
|
|
|
if (is_before_linux_ver(2, 6, 0) && use_bsize > 4096)
|
2013-12-11 05:18:37 +04:00
|
|
|
use_bsize = 4096;
|
|
|
|
}
|
|
|
|
if (lsector_size && use_bsize < lsector_size)
|
|
|
|
use_bsize = lsector_size;
|
|
|
|
if ((blocksize < 0) && (use_bsize < (-blocksize)))
|
|
|
|
use_bsize = -blocksize;
|
|
|
|
blocksize = use_bsize;
|
|
|
|
fs_blocks_count /= (blocksize / 1024);
|
|
|
|
} else {
|
|
|
|
if (blocksize < lsector_size) { /* Impossible */
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, EINVAL, "%s",
|
2013-12-11 05:18:37 +04:00
|
|
|
_("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);
|
|
|
|
|
2010-06-13 22:00:00 +04:00
|
|
|
/*
|
|
|
|
* We now need to do a sanity check of fs_blocks_count for
|
|
|
|
* 32-bit vs 64-bit block number support.
|
|
|
|
*/
|
2013-07-04 13:05:10 +04:00
|
|
|
if ((fs_blocks_count > MAX_32_NUM) &&
|
|
|
|
(fs_param.s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT))
|
|
|
|
fs_param.s_feature_compat &= ~EXT2_FEATURE_COMPAT_RESIZE_INODE;
|
2010-06-13 22:00:00 +04:00
|
|
|
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);
|
|
|
|
|
2008-07-07 04:24:29 +04:00
|
|
|
if (fs_param.s_feature_incompat & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV) {
|
|
|
|
fs_types[0] = strdup("journal");
|
|
|
|
fs_types[1] = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (verbose) {
|
|
|
|
fputs(_("fs_types for mke2fs.conf resolution: "), stdout);
|
|
|
|
print_str_list(fs_types);
|
|
|
|
}
|
|
|
|
|
2008-08-28 07:07:54 +04:00
|
|
|
if (r_opt == EXT2_GOOD_OLD_REV &&
|
2006-10-18 08:31:11 +04:00
|
|
|
(fs_param.s_feature_compat || fs_param.s_feature_incompat ||
|
2008-07-19 05:08:56 +04:00
|
|
|
fs_param.s_feature_ro_compat)) {
|
2013-12-16 07:11:40 +04:00
|
|
|
fprintf(stderr, "%s", _("Filesystem features not supported "
|
|
|
|
"with revision 0 filesystems\n"));
|
2006-03-24 06:00:01 +03:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2006-10-18 08:31:11 +04:00
|
|
|
if (s_opt > 0) {
|
|
|
|
if (r_opt == EXT2_GOOD_OLD_REV) {
|
2013-12-16 07:11:40 +04:00
|
|
|
fprintf(stderr, "%s",
|
|
|
|
_("Sparse superblocks not supported "
|
2006-10-18 08:31:11 +04:00
|
|
|
"with revision 0 filesystems\n"));
|
|
|
|
exit(1);
|
|
|
|
}
|
2006-03-24 06:00:01 +03:00
|
|
|
fs_param.s_feature_ro_compat |=
|
|
|
|
EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER;
|
2006-10-18 08:31:11 +04:00
|
|
|
} else if (s_opt == 0)
|
2006-03-24 06:00:01 +03:00
|
|
|
fs_param.s_feature_ro_compat &=
|
|
|
|
~EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER;
|
|
|
|
|
2006-10-18 08:31:11 +04:00
|
|
|
if (journal_size != 0) {
|
|
|
|
if (r_opt == EXT2_GOOD_OLD_REV) {
|
2013-12-16 07:11:40 +04:00
|
|
|
fprintf(stderr, "%s", _("Journals not supported with "
|
|
|
|
"revision 0 filesystems\n"));
|
2006-10-18 08:31:11 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
2008-08-28 07:07:54 +04:00
|
|
|
fs_param.s_feature_compat |=
|
2006-03-24 06:00:01 +03:00
|
|
|
EXT3_FEATURE_COMPAT_HAS_JOURNAL;
|
2006-10-18 08:31:11 +04:00
|
|
|
}
|
2006-03-24 06:00:01 +03:00
|
|
|
|
2011-05-11 01:51:31 +04:00
|
|
|
/* 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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-28 07:07:54 +04:00
|
|
|
if (fs_param.s_feature_incompat &
|
2006-03-24 06:00:01 +03:00
|
|
|
EXT3_FEATURE_INCOMPAT_JOURNAL_DEV) {
|
|
|
|
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;
|
|
|
|
}
|
2008-04-27 08:08:14 +04:00
|
|
|
|
2013-10-12 05:20:22 +04:00
|
|
|
/* Check the user's mkfs options for 64bit */
|
|
|
|
if ((fs_param.s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT) &&
|
|
|
|
!(fs_param.s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS)) {
|
2013-12-16 07:11:40 +04:00
|
|
|
printf("%s", _("Extents MUST be enabled for a 64-bit "
|
|
|
|
"filesystem. Pass -O extents to rectify.\n"));
|
2013-10-12 05:20:22 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2002-10-20 08:38:57 +04:00
|
|
|
/* Set first meta blockgroup via an environment variable */
|
|
|
|
/* (this is mostly for debugging purposes) */
|
2005-12-11 05:50:30 +03:00
|
|
|
if ((fs_param.s_feature_incompat & EXT2_FEATURE_INCOMPAT_META_BG) &&
|
2002-10-20 08:38:57 +04:00
|
|
|
((tmp = getenv("MKE2FS_FIRST_META_BG"))))
|
2005-12-11 05:50:30 +03:00
|
|
|
fs_param.s_first_meta_bg = atoi(tmp);
|
2011-06-11 02:57:22 +04:00
|
|
|
if (fs_param.s_feature_ro_compat & EXT4_FEATURE_RO_COMPAT_BIGALLOC) {
|
2011-06-14 22:30:22 +04:00
|
|
|
if (!cluster_size)
|
|
|
|
cluster_size = get_int_from_profile(fs_types,
|
|
|
|
"cluster_size",
|
2011-06-16 18:11:06 +04:00
|
|
|
blocksize*16);
|
2011-06-14 22:30:22 +04:00
|
|
|
fs_param.s_log_cluster_size =
|
|
|
|
int_log2(cluster_size >> EXT2_MIN_CLUSTER_LOG_SIZE);
|
2013-01-15 02:28:00 +04:00
|
|
|
if (fs_param.s_log_cluster_size &&
|
|
|
|
fs_param.s_log_cluster_size < fs_param.s_log_block_size) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, 0, "%s",
|
2013-01-15 02:28:00 +04:00
|
|
|
_("The cluster size may not be "
|
|
|
|
"smaller than the block size.\n"));
|
|
|
|
exit(1);
|
|
|
|
}
|
2013-01-13 13:08:13 +04:00
|
|
|
} else if (cluster_size) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, 0, "%s",
|
2013-01-13 13:08:13 +04:00
|
|
|
_("specifying a cluster size requires the "
|
|
|
|
"bigalloc feature"));
|
|
|
|
exit(1);
|
2011-06-11 02:57:22 +04:00
|
|
|
} else
|
|
|
|
fs_param.s_log_cluster_size = fs_param.s_log_block_size;
|
|
|
|
|
2006-03-24 06:00:01 +03:00
|
|
|
if (inode_ratio == 0) {
|
2008-02-19 16:32:58 +03:00
|
|
|
inode_ratio = get_int_from_profile(fs_types, "inode_ratio",
|
|
|
|
8192);
|
2006-03-24 06:00:01 +03:00
|
|
|
if (inode_ratio < blocksize)
|
|
|
|
inode_ratio = blocksize;
|
2011-06-11 02:57:22 +04:00
|
|
|
if (inode_ratio < EXT2_CLUSTER_SIZE(&fs_param))
|
|
|
|
inode_ratio = EXT2_CLUSTER_SIZE(&fs_param);
|
2006-03-24 06:00:01 +03:00
|
|
|
}
|
|
|
|
|
2009-10-02 20:32:42 +04:00
|
|
|
#ifdef HAVE_BLKID_PROBE_GET_TOPOLOGY
|
2010-11-22 18:50:42 +03:00
|
|
|
retval = get_device_geometry(device_name, &fs_param, psector_size);
|
2009-10-02 20:32:42 +04:00
|
|
|
if (retval < 0) {
|
|
|
|
fprintf(stderr,
|
2010-01-24 06:50:45 +03:00
|
|
|
_("warning: Unable to get device geometry for %s\n"),
|
2009-10-02 20:32:42 +04:00
|
|
|
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"));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-01-12 07:11:42 +04:00
|
|
|
num_backups = get_int_from_profile(fs_types, "num_backup_sb", 2);
|
|
|
|
|
2005-12-11 05:50:30 +03:00
|
|
|
blocksize = EXT2_BLOCK_SIZE(&fs_param);
|
2008-04-18 18:19:27 +04:00
|
|
|
|
2012-12-29 03:26:12 +04:00
|
|
|
/*
|
|
|
|
* Initialize s_desc_size so that the parse_extended_opts()
|
|
|
|
* can correctly handle "-E resize=NNN" if the 64-bit option
|
|
|
|
* is set.
|
|
|
|
*/
|
|
|
|
if (fs_param.s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
|
|
|
|
fs_param.s_desc_size = EXT2_MIN_DESC_SIZE_64BIT;
|
|
|
|
|
2011-09-16 07:08:52 +04:00
|
|
|
/* 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);
|
2014-04-27 01:34:52 +04:00
|
|
|
proceed_question(proceed_delay);
|
2011-09-16 07:08:52 +04:00
|
|
|
}
|
|
|
|
fprintf(stderr, _("Warning: %d-byte blocks too big for system "
|
|
|
|
"(max %d), forced to continue\n"),
|
|
|
|
blocksize, sys_page_size);
|
|
|
|
}
|
|
|
|
|
2010-10-01 18:47:38 +04:00
|
|
|
lazy_itable_init = 0;
|
|
|
|
if (access("/sys/fs/ext4/features/lazy_itable_init", R_OK) == 0)
|
|
|
|
lazy_itable_init = 1;
|
|
|
|
|
2008-08-28 07:07:54 +04:00
|
|
|
lazy_itable_init = get_bool_from_profile(fs_types,
|
2010-10-01 18:47:38 +04:00
|
|
|
"lazy_itable_init",
|
|
|
|
lazy_itable_init);
|
2010-11-18 16:38:41 +03:00
|
|
|
discard = get_bool_from_profile(fs_types, "discard" , discard);
|
2011-06-11 20:17:29 +04:00
|
|
|
journal_flags |= get_bool_from_profile(fs_types,
|
|
|
|
"lazy_journal_init", 0) ?
|
|
|
|
EXT2_MKJOURNAL_LAZYINIT : 0;
|
2012-04-05 23:30:02 +04:00
|
|
|
journal_flags |= EXT2_MKJOURNAL_NO_MNT_CHECK;
|
2008-08-28 07:07:54 +04:00
|
|
|
|
2014-01-28 21:58:56 +04:00
|
|
|
if (!journal_location_string)
|
|
|
|
journal_location_string = get_string_from_profile(fs_types,
|
|
|
|
"journal_location", "");
|
|
|
|
if ((journal_location == ~0ULL) && journal_location_string &&
|
|
|
|
*journal_location_string)
|
|
|
|
journal_location = parse_num_blocks2(journal_location_string,
|
|
|
|
fs_param.s_log_block_size);
|
|
|
|
free(journal_location_string);
|
|
|
|
|
2014-01-28 23:44:23 +04:00
|
|
|
packed_meta_blocks = get_bool_from_profile(fs_types,
|
|
|
|
"packed_meta_blocks", 0);
|
|
|
|
if (packed_meta_blocks)
|
|
|
|
journal_location = 0;
|
|
|
|
|
2008-05-15 02:09:37 +04:00
|
|
|
/* Get options from profile */
|
|
|
|
for (cpp = fs_types; *cpp; cpp++) {
|
|
|
|
tmp = NULL;
|
|
|
|
profile_get_string(profile, "fs_types", *cpp, "options", "", &tmp);
|
|
|
|
if (tmp && *tmp)
|
|
|
|
parse_extended_opts(&fs_param, tmp);
|
2009-02-23 20:07:50 +03:00
|
|
|
free(tmp);
|
2008-05-15 02:09:37 +04:00
|
|
|
}
|
|
|
|
|
2005-01-05 19:12:20 +03:00
|
|
|
if (extended_opts)
|
2005-12-11 05:50:30 +03:00
|
|
|
parse_extended_opts(&fs_param, extended_opts);
|
2004-12-15 22:39:16 +03:00
|
|
|
|
2013-01-06 16:25:17 +04:00
|
|
|
/* Can't support bigalloc feature without extents feature */
|
|
|
|
if ((fs_param.s_feature_ro_compat & EXT4_FEATURE_RO_COMPAT_BIGALLOC) &&
|
|
|
|
!(fs_param.s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS)) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, 0, "%s",
|
2013-01-06 16:25:17 +04:00
|
|
|
_("Can't support bigalloc feature without "
|
|
|
|
"extents feature"));
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2013-10-18 08:49:16 +04:00
|
|
|
if ((fs_param.s_feature_incompat & EXT2_FEATURE_INCOMPAT_META_BG) &&
|
|
|
|
(fs_param.s_feature_compat & EXT2_FEATURE_COMPAT_RESIZE_INODE)) {
|
2013-12-16 07:11:40 +04:00
|
|
|
fprintf(stderr, "%s", _("The resize_inode and meta_bg "
|
|
|
|
"features are not compatible.\n"
|
|
|
|
"They can not be both enabled "
|
|
|
|
"simultaneously.\n"));
|
2013-10-18 08:49:16 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2013-04-01 04:29:46 +04:00
|
|
|
if (!quiet &&
|
|
|
|
(fs_param.s_feature_ro_compat & EXT4_FEATURE_RO_COMPAT_BIGALLOC))
|
2013-12-16 07:11:40 +04:00
|
|
|
fprintf(stderr, "%s", _("\nWarning: the bigalloc feature is "
|
|
|
|
"still under development\n"
|
2013-01-22 04:07:38 +04:00
|
|
|
"See https://ext4.wiki.kernel.org/"
|
|
|
|
"index.php/Bigalloc for more information\n\n"));
|
|
|
|
|
2004-12-15 22:39:16 +03:00
|
|
|
/* Since sparse_super is the default, we would only have a problem
|
|
|
|
* here if it was explicitly disabled.
|
|
|
|
*/
|
2005-12-11 05:50:30 +03:00
|
|
|
if ((fs_param.s_feature_compat & EXT2_FEATURE_COMPAT_RESIZE_INODE) &&
|
|
|
|
!(fs_param.s_feature_ro_compat&EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, 0, "%s",
|
2004-12-15 22:39:16 +03:00
|
|
|
_("reserved online resize blocks not supported "
|
|
|
|
"on non-sparse filesystem"));
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2005-12-11 05:50:30 +03:00
|
|
|
if (fs_param.s_blocks_per_group) {
|
|
|
|
if (fs_param.s_blocks_per_group < 256 ||
|
|
|
|
fs_param.s_blocks_per_group > 8 * (unsigned) blocksize) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, 0, "%s",
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
_("blocks per group count out of range"));
|
1997-04-29 21:48:10 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-15 02:30:23 +04:00
|
|
|
/*
|
|
|
|
* If the bigalloc feature is enabled, then the -g option will
|
|
|
|
* specify the number of clusters per group.
|
|
|
|
*/
|
|
|
|
if (fs_param.s_feature_ro_compat & EXT4_FEATURE_RO_COMPAT_BIGALLOC) {
|
|
|
|
fs_param.s_clusters_per_group = fs_param.s_blocks_per_group;
|
|
|
|
fs_param.s_blocks_per_group = 0;
|
|
|
|
}
|
|
|
|
|
2008-02-19 16:32:58 +03:00
|
|
|
if (inode_size == 0)
|
|
|
|
inode_size = get_int_from_profile(fs_types, "inode_size", 0);
|
2008-04-22 16:27:01 +04:00
|
|
|
if (!flex_bg_size && (fs_param.s_feature_incompat &
|
|
|
|
EXT4_FEATURE_INCOMPAT_FLEX_BG))
|
|
|
|
flex_bg_size = get_int_from_profile(fs_types,
|
|
|
|
"flex_bg_size", 16);
|
|
|
|
if (flex_bg_size) {
|
|
|
|
if (!(fs_param.s_feature_incompat &
|
|
|
|
EXT4_FEATURE_INCOMPAT_FLEX_BG)) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, 0, "%s",
|
2008-04-22 16:27:01 +04:00
|
|
|
_("Flex_bg feature not enabled, so "
|
|
|
|
"flex_bg size may not be specified"));
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
fs_param.s_log_groups_per_flex = int_log2(flex_bg_size);
|
|
|
|
}
|
2006-07-16 06:08:20 +04:00
|
|
|
|
|
|
|
if (inode_size && fs_param.s_rev_level >= EXT2_DYNAMIC_REV) {
|
2002-05-16 13:20:07 +04:00
|
|
|
if (inode_size < EXT2_GOOD_OLD_INODE_SIZE ||
|
2005-12-11 05:50:30 +03:00
|
|
|
inode_size > EXT2_BLOCK_SIZE(&fs_param) ||
|
2002-05-16 13:20:07 +04:00
|
|
|
inode_size & (inode_size - 1)) {
|
|
|
|
com_err(program_name, 0,
|
2005-06-20 16:35:27 +04:00
|
|
|
_("invalid inode size %d (min %d/max %d)"),
|
2002-05-16 13:20:07 +04:00
|
|
|
inode_size, EXT2_GOOD_OLD_INODE_SIZE,
|
2003-04-12 06:10:50 +04:00
|
|
|
blocksize);
|
2002-05-16 13:20:07 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
2005-12-11 05:50:30 +03:00
|
|
|
fs_param.s_inode_size = inode_size;
|
2002-05-16 13:20:07 +04:00
|
|
|
}
|
|
|
|
|
2006-09-12 22:56:17 +04:00
|
|
|
/* Make sure number of inodes specified will fit in 32 bits */
|
|
|
|
if (num_inodes == 0) {
|
2007-05-25 19:18:11 +04:00
|
|
|
unsigned long long n;
|
2009-09-08 04:46:34 +04:00
|
|
|
n = ext2fs_blocks_count(&fs_param) * blocksize / inode_ratio;
|
2010-06-13 22:00:00 +04:00
|
|
|
if (n > MAX_32_NUM) {
|
2010-06-13 21:00:00 +04:00
|
|
|
if (fs_param.s_feature_incompat &
|
|
|
|
EXT4_FEATURE_INCOMPAT_64BIT)
|
2010-06-13 22:00:00 +04:00
|
|
|
num_inodes = MAX_32_NUM;
|
2010-06-13 21:00:00 +04:00
|
|
|
else {
|
|
|
|
com_err(program_name, 0,
|
2011-10-08 21:32:00 +04:00
|
|
|
_("too many inodes (%llu), raise "
|
2010-06-13 21:00:00 +04:00
|
|
|
"inode ratio?"), n);
|
|
|
|
exit(1);
|
|
|
|
}
|
2006-09-12 22:56:17 +04:00
|
|
|
}
|
2010-06-13 22:00:00 +04:00
|
|
|
} else if (num_inodes > MAX_32_NUM) {
|
2006-09-12 22:56:17 +04:00
|
|
|
com_err(program_name, 0,
|
|
|
|
_("too many inodes (%llu), specify < 2^32 inodes"),
|
2007-05-25 19:18:11 +04:00
|
|
|
num_inodes);
|
2006-09-12 22:56:17 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
1997-04-26 17:21:57 +04:00
|
|
|
/*
|
|
|
|
* Calculate number of inodes based on the inode ratio
|
|
|
|
*/
|
2008-08-28 07:07:54 +04:00
|
|
|
fs_param.s_inodes_count = num_inodes ? num_inodes :
|
2009-09-08 04:46:34 +04:00
|
|
|
(ext2fs_blocks_count(&fs_param) * blocksize) / inode_ratio;
|
1997-04-26 17:21:57 +04:00
|
|
|
|
2013-05-20 04:03:48 +04:00
|
|
|
if ((((unsigned long long)fs_param.s_inodes_count) *
|
2007-05-23 00:04:51 +04:00
|
|
|
(inode_size ? inode_size : EXT2_GOOD_OLD_INODE_SIZE)) >=
|
2009-09-08 04:46:34 +04:00
|
|
|
((ext2fs_blocks_count(&fs_param)) *
|
2007-05-23 00:04:51 +04:00
|
|
|
EXT2_BLOCK_SIZE(&fs_param))) {
|
|
|
|
com_err(program_name, 0, _("inode_size (%u) * inodes_count "
|
|
|
|
"(%u) too big for a\n\t"
|
2009-09-08 04:46:34 +04:00
|
|
|
"filesystem with %llu blocks, "
|
2007-05-23 00:04:51 +04:00
|
|
|
"specify higher inode_ratio (-i)\n\t"
|
|
|
|
"or lower inode count (-N).\n"),
|
|
|
|
inode_size ? inode_size : EXT2_GOOD_OLD_INODE_SIZE,
|
2008-08-28 07:07:54 +04:00
|
|
|
fs_param.s_inodes_count,
|
2009-09-08 04:46:34 +04:00
|
|
|
(unsigned long long) ext2fs_blocks_count(&fs_param));
|
2007-05-23 00:04:51 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
/*
|
|
|
|
* Calculate number of blocks to reserve
|
|
|
|
*/
|
2009-09-08 04:46:34 +04:00
|
|
|
ext2fs_r_blocks_count_set(&fs_param, reserved_ratio *
|
|
|
|
ext2fs_blocks_count(&fs_param) / 100.0);
|
2011-06-14 22:17:56 +04:00
|
|
|
|
2014-01-12 07:11:42 +04:00
|
|
|
if (fs_param.s_feature_compat & EXT4_FEATURE_COMPAT_SPARSE_SUPER2) {
|
|
|
|
if (num_backups >= 1)
|
|
|
|
fs_param.s_backup_bgs[0] = 1;
|
|
|
|
if (num_backups >= 2)
|
|
|
|
fs_param.s_backup_bgs[1] = ~0;
|
|
|
|
}
|
|
|
|
|
2011-06-14 22:17:56 +04:00
|
|
|
free(fs_type);
|
|
|
|
free(usage_types);
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
2004-12-15 22:39:16 +03:00
|
|
|
|
2007-08-13 14:26:26 +04:00
|
|
|
static int should_do_undo(const char *name)
|
|
|
|
{
|
|
|
|
errcode_t retval;
|
|
|
|
io_channel channel;
|
|
|
|
__u16 s_magic;
|
|
|
|
struct ext2_super_block super;
|
|
|
|
io_manager manager = unix_io_manager;
|
|
|
|
int csum_flag, force_undo;
|
|
|
|
|
|
|
|
csum_flag = EXT2_HAS_RO_COMPAT_FEATURE(&fs_param,
|
|
|
|
EXT4_FEATURE_RO_COMPAT_GDT_CSUM);
|
|
|
|
force_undo = get_int_from_profile(fs_types, "force_undo", 0);
|
|
|
|
if (!force_undo && (!csum_flag || !lazy_itable_init))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
retval = manager->open(name, IO_FLAG_EXCLUSIVE, &channel);
|
|
|
|
if (retval) {
|
|
|
|
/*
|
|
|
|
* We don't handle error cases instead we
|
|
|
|
* declare that the file system doesn't exist
|
|
|
|
* and let the rest of mke2fs take care of
|
|
|
|
* error
|
|
|
|
*/
|
|
|
|
retval = 0;
|
|
|
|
goto open_err_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
io_channel_set_blksize(channel, SUPERBLOCK_OFFSET);
|
2009-09-08 05:14:24 +04:00
|
|
|
retval = io_channel_read_blk64(channel, 1, -SUPERBLOCK_SIZE, &super);
|
2007-08-13 14:26:26 +04:00
|
|
|
if (retval) {
|
|
|
|
retval = 0;
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(WORDS_BIGENDIAN)
|
|
|
|
s_magic = ext2fs_swab16(super.s_magic);
|
|
|
|
#else
|
|
|
|
s_magic = super.s_magic;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (s_magic == EXT2_SUPER_MAGIC)
|
|
|
|
retval = 1;
|
|
|
|
|
|
|
|
err_out:
|
|
|
|
io_channel_close(channel);
|
|
|
|
|
|
|
|
open_err_out:
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mke2fs_setup_tdb(const char *name, io_manager *io_ptr)
|
|
|
|
{
|
2010-12-22 05:57:02 +03:00
|
|
|
errcode_t retval = ENOMEM;
|
2011-09-17 00:49:40 +04:00
|
|
|
char *tdb_dir = NULL, *tdb_file = NULL;
|
2013-05-20 04:03:48 +04:00
|
|
|
char *dev_name, *tmp_name;
|
2011-09-17 00:49:40 +04:00
|
|
|
int free_tdb_dir = 0;
|
2007-08-13 14:26:26 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Configuration via a conf file would be
|
|
|
|
* nice
|
|
|
|
*/
|
|
|
|
tdb_dir = getenv("E2FSPROGS_UNDO_DIR");
|
2011-09-17 00:49:40 +04:00
|
|
|
if (!tdb_dir) {
|
2007-08-13 14:26:26 +04:00
|
|
|
profile_get_string(profile, "defaults",
|
|
|
|
"undo_dir", 0, "/var/lib/e2fsprogs",
|
|
|
|
&tdb_dir);
|
2011-09-17 00:49:40 +04:00
|
|
|
free_tdb_dir = 1;
|
|
|
|
}
|
2007-08-13 14:26:26 +04:00
|
|
|
|
|
|
|
if (!strcmp(tdb_dir, "none") || (tdb_dir[0] == 0) ||
|
2013-12-12 22:06:44 +04:00
|
|
|
access(tdb_dir, W_OK)) {
|
|
|
|
if (free_tdb_dir)
|
|
|
|
free(tdb_dir);
|
2007-08-13 14:26:26 +04:00
|
|
|
return 0;
|
2013-12-12 22:06:44 +04:00
|
|
|
}
|
2007-08-13 14:26:26 +04:00
|
|
|
|
|
|
|
tmp_name = strdup(name);
|
2010-12-22 05:57:02 +03:00
|
|
|
if (!tmp_name)
|
|
|
|
goto errout;
|
2013-05-20 04:03:48 +04:00
|
|
|
dev_name = basename(tmp_name);
|
|
|
|
tdb_file = malloc(strlen(tdb_dir) + 8 + strlen(dev_name) + 7 + 1);
|
2010-12-22 05:57:02 +03:00
|
|
|
if (!tdb_file) {
|
|
|
|
free(tmp_name);
|
|
|
|
goto errout;
|
|
|
|
}
|
2013-05-20 04:03:48 +04:00
|
|
|
sprintf(tdb_file, "%s/mke2fs-%s.e2undo", tdb_dir, dev_name);
|
2010-12-22 05:57:02 +03:00
|
|
|
free(tmp_name);
|
2007-08-13 14:26:26 +04:00
|
|
|
|
2014-01-11 06:39:27 +04:00
|
|
|
if ((unlink(tdb_file) < 0) && (errno != ENOENT)) {
|
|
|
|
retval = errno;
|
|
|
|
goto errout;
|
2007-08-13 14:26:26 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
set_undo_io_backing_manager(*io_ptr);
|
|
|
|
*io_ptr = undo_io_manager;
|
2010-12-22 05:57:02 +03:00
|
|
|
retval = set_undo_io_backup_file(tdb_file);
|
|
|
|
if (retval)
|
|
|
|
goto errout;
|
2007-08-13 14:26:26 +04:00
|
|
|
printf(_("Overwriting existing filesystem; this can be undone "
|
|
|
|
"using the command:\n"
|
|
|
|
" e2undo %s %s\n\n"), tdb_file, name);
|
2008-07-07 02:36:56 +04:00
|
|
|
|
2011-09-17 00:49:40 +04:00
|
|
|
if (free_tdb_dir)
|
|
|
|
free(tdb_dir);
|
2009-04-18 18:53:32 +04:00
|
|
|
free(tdb_file);
|
2010-12-22 05:57:02 +03:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
errout:
|
2011-09-17 00:49:40 +04:00
|
|
|
if (free_tdb_dir)
|
|
|
|
free(tdb_dir);
|
2010-12-22 05:57:02 +03:00
|
|
|
free(tdb_file);
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, retval, "%s",
|
2010-12-22 05:57:02 +03:00
|
|
|
_("while trying to setup undo file\n"));
|
2007-08-13 14:26:26 +04:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2011-01-24 22:52:00 +03:00
|
|
|
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;
|
2011-09-16 07:44:59 +04:00
|
|
|
blk64_t cur;
|
2011-01-24 22:52:00 +03:00
|
|
|
int retval = 0;
|
|
|
|
|
2011-09-16 07:44:59 +04:00
|
|
|
/*
|
|
|
|
* 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);
|
2011-02-28 04:09:54 +03:00
|
|
|
if (retval)
|
|
|
|
return retval;
|
2011-09-16 07:44:59 +04:00
|
|
|
cur = fs->blocksize;
|
2011-02-28 04:09:54 +03:00
|
|
|
|
2011-01-24 22:52:00 +03:00
|
|
|
count *= (1024 * 1024);
|
|
|
|
count /= fs->blocksize;
|
|
|
|
|
|
|
|
ext2fs_numeric_progress_init(fs, &progress,
|
|
|
|
_("Discarding device blocks: "),
|
|
|
|
blocks);
|
|
|
|
while (cur < blocks) {
|
2012-09-23 05:26:48 +04:00
|
|
|
ext2fs_numeric_progress_update(fs, &progress, cur);
|
2011-01-24 22:52:00 +03:00
|
|
|
|
|
|
|
if (cur + count > blocks)
|
|
|
|
count = blocks - cur;
|
|
|
|
|
2011-02-28 04:09:54 +03:00
|
|
|
retval = io_channel_discard(fs->io, cur, count);
|
2011-01-24 22:52:00 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2011-06-16 06:17:38 +04:00
|
|
|
static void fix_cluster_bg_counts(ext2_filsys fs)
|
2011-06-11 02:57:22 +04:00
|
|
|
{
|
2014-01-20 04:44:45 +04:00
|
|
|
blk64_t block, num_blocks, last_block, next;
|
|
|
|
blk64_t tot_free = 0;
|
|
|
|
errcode_t retval;
|
|
|
|
dgrp_t group = 0;
|
|
|
|
int grp_free = 0;
|
|
|
|
|
|
|
|
num_blocks = ext2fs_blocks_count(fs->super);
|
|
|
|
last_block = ext2fs_group_last_block2(fs, group);
|
|
|
|
block = fs->super->s_first_data_block;
|
|
|
|
while (block < num_blocks) {
|
|
|
|
retval = ext2fs_find_first_zero_block_bitmap2(fs->block_map,
|
|
|
|
block, last_block, &next);
|
|
|
|
if (retval == 0)
|
|
|
|
block = next;
|
|
|
|
else {
|
|
|
|
block = last_block + 1;
|
|
|
|
goto next_bg;
|
2011-06-11 02:57:22 +04:00
|
|
|
}
|
2014-01-20 04:44:45 +04:00
|
|
|
|
|
|
|
retval = ext2fs_find_first_set_block_bitmap2(fs->block_map,
|
|
|
|
block, last_block, &next);
|
|
|
|
if (retval)
|
|
|
|
next = last_block + 1;
|
|
|
|
grp_free += EXT2FS_NUM_B2C(fs, next - block);
|
|
|
|
tot_free += next - block;
|
|
|
|
block = next;
|
|
|
|
|
|
|
|
if (block > last_block) {
|
|
|
|
next_bg:
|
2011-06-11 02:57:22 +04:00
|
|
|
ext2fs_bg_free_blocks_count_set(fs, group, grp_free);
|
|
|
|
ext2fs_group_desc_csum_set(fs, group);
|
|
|
|
grp_free = 0;
|
|
|
|
group++;
|
2014-01-20 04:44:45 +04:00
|
|
|
last_block = ext2fs_group_last_block2(fs, group);
|
2011-06-11 02:57:22 +04:00
|
|
|
}
|
|
|
|
}
|
2014-01-20 04:44:45 +04:00
|
|
|
ext2fs_free_blocks_count_set(fs->super, tot_free);
|
2011-06-11 02:57:22 +04:00
|
|
|
}
|
|
|
|
|
2011-07-20 22:40:04 +04:00
|
|
|
static int create_quota_inodes(ext2_filsys fs)
|
|
|
|
{
|
|
|
|
quota_ctx_t qctx;
|
|
|
|
|
2011-11-14 19:55:54 +04:00
|
|
|
quota_init_context(&qctx, fs, -1);
|
|
|
|
quota_compute_usage(qctx);
|
2011-11-14 19:55:54 +04:00
|
|
|
quota_write_inode(qctx, quotatype);
|
2011-11-14 19:55:54 +04:00
|
|
|
quota_release_context(&qctx);
|
2011-07-20 22:40:04 +04:00
|
|
|
|
2011-11-14 19:55:54 +04:00
|
|
|
return 0;
|
2011-07-20 22:40:04 +04:00
|
|
|
}
|
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
int main (int argc, char *argv[])
|
|
|
|
{
|
|
|
|
errcode_t retval = 0;
|
|
|
|
ext2_filsys fs;
|
|
|
|
badblocks_list bb_list = 0;
|
2014-04-14 20:20:25 +04:00
|
|
|
unsigned int journal_blocks = 0;
|
2011-09-29 06:45:12 +04:00
|
|
|
unsigned int i, checkinterval;
|
|
|
|
int max_mnt_count;
|
2008-08-30 05:39:36 +04:00
|
|
|
int val, hash_alg;
|
2009-08-05 08:17:56 +04:00
|
|
|
int flags;
|
|
|
|
int old_bitmaps;
|
2003-07-09 02:03:48 +04:00
|
|
|
io_manager io_ptr;
|
2013-12-31 08:03:09 +04:00
|
|
|
char opt_string[40];
|
2008-08-30 05:39:36 +04:00
|
|
|
char *hash_alg_str;
|
2010-08-21 01:41:14 +04:00
|
|
|
int itable_zeroed = 0;
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
|
|
|
|
#ifdef ENABLE_NLS
|
|
|
|
setlocale(LC_MESSAGES, "");
|
2002-03-05 11:26:52 +03:00
|
|
|
setlocale(LC_CTYPE, "");
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
|
|
|
|
textdomain(NLS_CAT_NAME);
|
2011-10-05 09:00:30 +04:00
|
|
|
set_com_err_gettext(gettext);
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
#endif
|
1997-04-26 17:21:57 +04:00
|
|
|
PRS(argc, argv);
|
|
|
|
|
2003-07-09 02:03:48 +04:00
|
|
|
#ifdef CONFIG_TESTIO_DEBUG
|
2008-09-01 19:17:29 +04:00
|
|
|
if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_BLOCK")) {
|
|
|
|
io_ptr = test_io_manager;
|
|
|
|
test_io_backing_manager = unix_io_manager;
|
|
|
|
} else
|
2003-07-09 02:03:48 +04:00
|
|
|
#endif
|
2008-09-01 19:17:29 +04:00
|
|
|
io_ptr = unix_io_manager;
|
2003-07-09 02:03:48 +04:00
|
|
|
|
2007-08-13 14:26:26 +04:00
|
|
|
if (should_do_undo(device_name)) {
|
|
|
|
retval = mke2fs_setup_tdb(device_name, &io_ptr);
|
|
|
|
if (retval)
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
/*
|
|
|
|
* Initialize the superblock....
|
|
|
|
*/
|
2009-08-05 08:17:56 +04:00
|
|
|
flags = EXT2_FLAG_EXCLUSIVE;
|
2012-03-23 00:00:49 +04:00
|
|
|
if (direct_io)
|
|
|
|
flags |= EXT2_FLAG_DIRECT_IO;
|
2009-08-05 08:17:56 +04:00
|
|
|
profile_get_boolean(profile, "options", "old_bitmaps", 0, 0,
|
|
|
|
&old_bitmaps);
|
|
|
|
if (!old_bitmaps)
|
|
|
|
flags |= EXT2_FLAG_64BITS;
|
2009-08-24 03:20:03 +04:00
|
|
|
/*
|
|
|
|
* By default, we print how many inode tables or block groups
|
|
|
|
* or whatever we've written so far. The quiet flag disables
|
|
|
|
* this, along with a lot of other output.
|
|
|
|
*/
|
|
|
|
if (!quiet)
|
|
|
|
flags |= EXT2_FLAG_PRINT_PROGRESS;
|
2009-08-05 08:17:56 +04:00
|
|
|
retval = ext2fs_initialize(device_name, flags, &fs_param, io_ptr, &fs);
|
1997-04-26 17:21:57 +04:00
|
|
|
if (retval) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(device_name, retval, "%s",
|
|
|
|
_("while setting up superblock"));
|
1997-04-26 17:21:57 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
2009-08-24 03:20:03 +04:00
|
|
|
|
2013-05-11 07:42:13 +04:00
|
|
|
/* Calculate journal blocks */
|
|
|
|
if (!journal_device && ((journal_size) ||
|
|
|
|
(fs_param.s_feature_compat &
|
|
|
|
EXT3_FEATURE_COMPAT_HAS_JOURNAL)))
|
|
|
|
journal_blocks = figure_journal_size(journal_size, fs);
|
|
|
|
|
2009-10-08 01:49:17 +04:00
|
|
|
/* Can't undo discard ... */
|
2014-05-05 07:40:58 +04:00
|
|
|
if (!noaction && discard && dev_size && (io_ptr != undo_io_manager)) {
|
2011-01-24 22:52:00 +03:00
|
|
|
retval = mke2fs_discard_device(fs);
|
2010-11-18 06:38:37 +03:00
|
|
|
if (!retval && io_channel_discard_zeroes_data(fs->io)) {
|
2010-08-21 01:41:14 +04:00
|
|
|
if (verbose)
|
2013-12-16 07:11:40 +04:00
|
|
|
printf("%s",
|
|
|
|
_("Discard succeeded and will return "
|
|
|
|
"0s - skipping inode table wipe\n"));
|
2010-08-21 01:41:14 +04:00
|
|
|
lazy_itable_init = 1;
|
|
|
|
itable_zeroed = 1;
|
2014-01-21 08:06:07 +04:00
|
|
|
zero_hugefile = 0;
|
2010-08-21 01:41:14 +04:00
|
|
|
}
|
|
|
|
}
|
2009-10-08 01:49:17 +04:00
|
|
|
|
2013-12-31 08:03:09 +04:00
|
|
|
sprintf(opt_string, "tdb_data_size=%d", fs->blocksize <= 4096 ?
|
2007-08-13 14:26:26 +04:00
|
|
|
32768 : fs->blocksize * 8);
|
2013-12-31 08:03:09 +04:00
|
|
|
io_channel_set_options(fs->io, opt_string);
|
|
|
|
if (offset) {
|
|
|
|
sprintf(opt_string, "offset=%llu", offset);
|
|
|
|
io_channel_set_options(fs->io, opt_string);
|
|
|
|
}
|
1997-04-26 17:21:57 +04:00
|
|
|
|
2008-01-27 03:06:35 +03:00
|
|
|
if (fs_param.s_flags & EXT2_FLAGS_TEST_FILESYS)
|
|
|
|
fs->super->s_flags |= EXT2_FLAGS_TEST_FILESYS;
|
|
|
|
|
2009-03-06 03:40:20 +03:00
|
|
|
if ((fs_param.s_feature_incompat &
|
|
|
|
(EXT3_FEATURE_INCOMPAT_EXTENTS|EXT4_FEATURE_INCOMPAT_FLEX_BG)) ||
|
|
|
|
(fs_param.s_feature_ro_compat &
|
|
|
|
(EXT4_FEATURE_RO_COMPAT_HUGE_FILE|EXT4_FEATURE_RO_COMPAT_GDT_CSUM|
|
|
|
|
EXT4_FEATURE_RO_COMPAT_DIR_NLINK|
|
|
|
|
EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE)))
|
|
|
|
fs->super->s_kbytes_written = 1;
|
|
|
|
|
2000-08-14 18:44:15 +04:00
|
|
|
/*
|
|
|
|
* Wipe out the old on-disk superblock
|
|
|
|
*/
|
2001-08-31 05:55:26 +04:00
|
|
|
if (!noaction)
|
|
|
|
zap_sector(fs, 2, 6);
|
2000-08-14 18:44:15 +04:00
|
|
|
|
1997-04-29 18:53:37 +04:00
|
|
|
/*
|
2009-01-20 21:18:23 +03:00
|
|
|
* Parse or generate a UUID for the filesystem
|
1997-04-29 18:53:37 +04:00
|
|
|
*/
|
2009-01-20 21:18:23 +03:00
|
|
|
if (fs_uuid) {
|
|
|
|
if (uuid_parse(fs_uuid, fs->super->s_uuid) !=0) {
|
|
|
|
com_err(device_name, 0, "could not parse UUID: %s\n",
|
|
|
|
fs_uuid);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
uuid_generate(fs->super->s_uuid);
|
1997-04-29 18:53:37 +04:00
|
|
|
|
2002-09-22 23:37:40 +04:00
|
|
|
/*
|
|
|
|
* Initialize the directory index variables
|
|
|
|
*/
|
2008-08-30 05:39:36 +04:00
|
|
|
hash_alg_str = get_string_from_profile(fs_types, "hash_alg",
|
|
|
|
"half_md4");
|
|
|
|
hash_alg = e2p_string2hash(hash_alg_str);
|
2010-12-02 02:49:26 +03:00
|
|
|
free(hash_alg_str);
|
2008-08-30 05:39:36 +04:00
|
|
|
fs->super->s_def_hash_version = (hash_alg >= 0) ? hash_alg :
|
|
|
|
EXT2_HASH_HALF_MD4;
|
2002-09-22 23:37:40 +04:00
|
|
|
uuid_generate((unsigned char *) fs->super->s_hash_seed);
|
|
|
|
|
2001-01-14 20:02:09 +03:00
|
|
|
/*
|
2011-02-18 00:55:15 +03:00
|
|
|
* 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.
|
2001-01-14 20:02:09 +03:00
|
|
|
*/
|
2011-02-18 00:55:15 +03:00
|
|
|
#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;
|
2011-09-29 06:45:12 +04:00
|
|
|
} else
|
|
|
|
fs->super->s_max_mnt_count = -1;
|
2001-01-14 20:02:09 +03:00
|
|
|
|
1997-04-29 18:53:37 +04:00
|
|
|
/*
|
|
|
|
* Override the creator OS, if applicable
|
|
|
|
*/
|
|
|
|
if (creator_os && !set_os(fs->super, creator_os)) {
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
com_err (program_name, 0, _("unknown os - %s"), creator_os);
|
1997-04-29 18:53:37 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
ChangeLog, problem.c, problem.h, super.c:
problem.c, problem.h (PR_0_HURD_CLEAR_FILETYPE): Add new problem code.
super.c (check_super_block): If the OS type in the superblock is the
Hurd, check to see if the filetype feature is set, and offer to clear
it if so. This needs to be done since the Hurd doesn't properly
support the filetype feature. (And since the hurd allows the
transmogrification of files to special files and vice versa --- for no
good reason that I can understand --- it can't support the filetype
feature for the forseeable future, either.)
ChangeLog, mke2fs.c:
mke2fs.c (main): We forcibly turn off the filetype feature if the OS
is the hurd, since the hurd doesn't support it. (And since the hurd
allows the transmogrification of files to special files and vice versa
--- for no good reason that I can understand --- it can't support the
filetype feature for the forseeable future, either.)
mke2fs.c (proceed_question): Fix reversed sense of proceed_question
that was busted due to the internationalization patch. Fixed bug
where if proceed_question was called twice, the input buffer wasn't
cleared of the previous question's newline.
ChangeLog, expect.1, expect.2, image.gz, name:
f_hurd: Add test for Hurd-specific features (right now, just checks to
make sure the filetype feature is cleared)
ChangeLog, ls.c:
ls.c (list_super): Change the string displayed for the Hurd to be
GNU/Hurd, instead of just "GNU".
2000-05-08 17:33:17 +04:00
|
|
|
/*
|
|
|
|
* For the Hurd, we will turn off filetype since it doesn't
|
|
|
|
* support it.
|
|
|
|
*/
|
|
|
|
if (fs->super->s_creator_os == EXT2_OS_HURD)
|
|
|
|
fs->super->s_feature_incompat &=
|
|
|
|
~EXT2_FEATURE_INCOMPAT_FILETYPE;
|
|
|
|
|
1997-04-29 18:53:37 +04:00
|
|
|
/*
|
|
|
|
* Set the volume label...
|
|
|
|
*/
|
|
|
|
if (volume_label) {
|
2001-01-01 18:31:53 +03:00
|
|
|
memset(fs->super->s_volume_name, 0,
|
|
|
|
sizeof(fs->super->s_volume_name));
|
|
|
|
strncpy(fs->super->s_volume_name, volume_label,
|
|
|
|
sizeof(fs->super->s_volume_name));
|
1997-04-29 18:53:37 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the last mount directory
|
|
|
|
*/
|
|
|
|
if (mount_dir) {
|
2001-01-01 18:31:53 +03:00
|
|
|
memset(fs->super->s_last_mounted, 0,
|
|
|
|
sizeof(fs->super->s_last_mounted));
|
|
|
|
strncpy(fs->super->s_last_mounted, mount_dir,
|
|
|
|
sizeof(fs->super->s_last_mounted));
|
1997-04-29 18:53:37 +04:00
|
|
|
}
|
2008-08-28 07:07:54 +04:00
|
|
|
|
1999-07-19 19:30:21 +04:00
|
|
|
if (!quiet || noaction)
|
1997-04-26 17:21:57 +04:00
|
|
|
show_stats(fs);
|
|
|
|
|
1999-07-19 19:30:21 +04:00
|
|
|
if (noaction)
|
|
|
|
exit(0);
|
|
|
|
|
2001-01-16 10:47:31 +03:00
|
|
|
if (fs->super->s_feature_incompat &
|
|
|
|
EXT3_FEATURE_INCOMPAT_JOURNAL_DEV) {
|
|
|
|
create_journal_dev(fs);
|
2014-07-06 05:06:29 +04:00
|
|
|
exit(ext2fs_close_free(&fs) ? 1 : 0);
|
2001-01-16 10:47:31 +03:00
|
|
|
}
|
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
if (bad_blocks_filename)
|
|
|
|
read_bb_file(fs, &bb_list, bad_blocks_filename);
|
|
|
|
if (cflag)
|
|
|
|
test_disk(fs, &bb_list);
|
|
|
|
handle_bad_blocks(fs, bb_list);
|
2014-01-12 07:11:42 +04:00
|
|
|
|
2008-02-19 06:56:25 +03:00
|
|
|
fs->stride = fs_stride = fs->super->s_raid_stride;
|
2009-08-24 03:20:03 +04:00
|
|
|
if (!quiet)
|
2013-12-16 07:11:40 +04:00
|
|
|
printf("%s", _("Allocating group tables: "));
|
2014-01-28 23:44:23 +04:00
|
|
|
if ((fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_FLEX_BG) &&
|
|
|
|
packed_meta_blocks)
|
|
|
|
retval = packed_allocate_tables(fs);
|
|
|
|
else
|
|
|
|
retval = ext2fs_allocate_tables(fs);
|
1997-04-29 20:17:09 +04:00
|
|
|
if (retval) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, retval, "%s",
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
_("while trying to allocate filesystem tables"));
|
1997-04-29 20:17:09 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
2009-08-24 03:20:03 +04:00
|
|
|
if (!quiet)
|
2013-12-16 07:11:40 +04:00
|
|
|
printf("%s", _("done \n"));
|
2011-06-11 02:57:22 +04:00
|
|
|
|
|
|
|
retval = ext2fs_convert_subcluster_bitmap(fs, &fs->block_map);
|
|
|
|
if (retval) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, retval, "%s",
|
2011-06-11 02:57:22 +04:00
|
|
|
_("\n\twhile converting subcluster bitmap"));
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
1997-04-26 17:34:30 +04:00
|
|
|
if (super_only) {
|
|
|
|
fs->super->s_state |= EXT2_ERROR_FS;
|
|
|
|
fs->flags &= ~(EXT2_FLAG_IB_DIRTY|EXT2_FLAG_BB_DIRTY);
|
2012-02-17 08:16:34 +04:00
|
|
|
/*
|
|
|
|
* 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) {
|
2012-02-27 09:51:39 +04:00
|
|
|
for (i = 0; i < fs->group_desc_count; i++)
|
2012-02-17 08:16:34 +04:00
|
|
|
ext2fs_bg_itable_unused_set(fs, i, 0);
|
|
|
|
}
|
1997-04-26 17:34:30 +04:00
|
|
|
} else {
|
2001-08-31 01:39:04 +04:00
|
|
|
/* rsv must be a power of two (64kB is MD RAID sb alignment) */
|
2010-06-13 21:00:00 +04:00
|
|
|
blk64_t rsv = 65536 / fs->blocksize;
|
|
|
|
blk64_t blocks = ext2fs_blocks_count(fs->super);
|
|
|
|
blk64_t start;
|
|
|
|
blk64_t ret_blk;
|
2001-05-14 08:19:25 +04:00
|
|
|
|
|
|
|
#ifdef ZAP_BOOTBLOCK
|
2001-08-31 05:55:26 +04:00
|
|
|
zap_sector(fs, 0, 2);
|
2001-05-14 08:19:25 +04:00
|
|
|
#endif
|
2001-08-31 01:39:04 +04:00
|
|
|
|
2001-05-14 08:19:25 +04:00
|
|
|
/*
|
|
|
|
* Wipe out any old MD RAID (or other) metadata at the end
|
|
|
|
* of the device. This will also verify that the device is
|
2001-08-31 01:39:04 +04:00
|
|
|
* as large as we think. Be careful with very small devices.
|
2001-05-14 08:19:25 +04:00
|
|
|
*/
|
2001-08-31 01:39:04 +04:00
|
|
|
start = (blocks & ~(rsv - 1));
|
|
|
|
if (start > rsv)
|
|
|
|
start -= rsv;
|
|
|
|
if (start > 0)
|
2010-06-13 21:00:00 +04:00
|
|
|
retval = ext2fs_zero_blocks2(fs, start, blocks - start,
|
2007-08-13 14:26:26 +04:00
|
|
|
&ret_blk, NULL);
|
2001-08-31 01:39:04 +04:00
|
|
|
|
2001-05-14 08:19:25 +04:00
|
|
|
if (retval) {
|
|
|
|
com_err(program_name, retval,
|
2010-06-13 21:00:00 +04:00
|
|
|
_("while zeroing block %llu at end of filesystem"),
|
2001-05-14 08:19:25 +04:00
|
|
|
ret_blk);
|
|
|
|
}
|
2010-08-21 01:41:14 +04:00
|
|
|
write_inode_tables(fs, lazy_itable_init, itable_zeroed);
|
1997-04-26 17:34:30 +04:00
|
|
|
create_root_dir(fs);
|
|
|
|
create_lost_and_found(fs);
|
|
|
|
reserve_inodes(fs);
|
|
|
|
create_bad_block_inode(fs, bb_list);
|
2008-08-28 07:07:54 +04:00
|
|
|
if (fs->super->s_feature_compat &
|
2005-01-28 19:45:28 +03:00
|
|
|
EXT2_FEATURE_COMPAT_RESIZE_INODE) {
|
|
|
|
retval = ext2fs_create_resize_inode(fs);
|
|
|
|
if (retval) {
|
|
|
|
com_err("ext2fs_create_resize_inode", retval,
|
2013-12-16 07:11:40 +04:00
|
|
|
"%s",
|
2004-12-15 22:39:16 +03:00
|
|
|
_("while reserving blocks for online resize"));
|
2005-01-28 19:45:28 +03:00
|
|
|
exit(1);
|
|
|
|
}
|
2004-12-15 22:39:16 +03:00
|
|
|
}
|
1997-04-26 17:34:30 +04:00
|
|
|
}
|
2000-11-17 07:55:24 +03:00
|
|
|
|
2001-01-16 10:47:31 +03:00
|
|
|
if (journal_device) {
|
|
|
|
ext2_filsys jfs;
|
2008-08-28 07:07:54 +04:00
|
|
|
|
2014-04-26 21:14:32 +04:00
|
|
|
if (!check_plausibility(journal_device, CHECK_BLOCK_DEV,
|
|
|
|
NULL) && !force)
|
2014-04-27 01:34:52 +04:00
|
|
|
proceed_question(proceed_delay);
|
ChangeLog, Makefile.in, mke2fs.c, tune2fs.8.in, tune2fs.c, util.c, util.h:
tune2fs.c (update_feature_set, add_journal): Moved to separate
functions. Added ability to add and remove the journal while the
filesystem is live. Added support for setting a time-based UUID.
Removed zero-initialized static variables.
mke2fs.c, util.c, util.h (strcasecmp, proceed_question,
check_plausibility, parse_journal_opts, check_mount): Moved functions
to util.c so they can be used by tune2fs.
mke2fs.c (main): Change ext2fs_add_journal_fs() to
ext2fs_add_journal_inode() to reflect function renaming.
2001-01-03 20:02:13 +03:00
|
|
|
check_mount(journal_device, force, _("journal"));
|
2000-11-17 07:55:24 +03:00
|
|
|
|
2001-01-16 10:47:31 +03:00
|
|
|
retval = ext2fs_open(journal_device, EXT2_FLAG_RW|
|
|
|
|
EXT2_FLAG_JOURNAL_DEV_OK, 0,
|
|
|
|
fs->blocksize, unix_io_manager, &jfs);
|
|
|
|
if (retval) {
|
|
|
|
com_err(program_name, retval,
|
|
|
|
_("while trying to open journal device %s\n"),
|
|
|
|
journal_device);
|
|
|
|
exit(1);
|
|
|
|
}
|
2001-02-17 09:09:50 +03:00
|
|
|
if (!quiet) {
|
2008-08-28 07:07:54 +04:00
|
|
|
printf(_("Adding journal to device %s: "),
|
2000-11-17 07:55:24 +03:00
|
|
|
journal_device);
|
2001-02-17 09:09:50 +03:00
|
|
|
fflush(stdout);
|
|
|
|
}
|
2001-01-16 10:47:31 +03:00
|
|
|
retval = ext2fs_add_journal_device(fs, jfs);
|
|
|
|
if(retval) {
|
2008-08-28 07:07:54 +04:00
|
|
|
com_err (program_name, retval,
|
|
|
|
_("\n\twhile trying to add journal to device %s"),
|
2000-11-17 07:55:24 +03:00
|
|
|
journal_device);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
if (!quiet)
|
2013-12-16 07:11:40 +04:00
|
|
|
printf("%s", _("done\n"));
|
2014-07-06 05:06:29 +04:00
|
|
|
ext2fs_close_free(&jfs);
|
2001-08-17 13:48:11 +04:00
|
|
|
free(journal_device);
|
2006-03-24 06:00:01 +03:00
|
|
|
} else if ((journal_size) ||
|
2008-08-28 07:07:54 +04:00
|
|
|
(fs_param.s_feature_compat &
|
2006-03-24 06:00:01 +03:00
|
|
|
EXT3_FEATURE_COMPAT_HAS_JOURNAL)) {
|
2009-03-31 15:42:24 +04:00
|
|
|
if (super_only) {
|
2013-12-16 07:11:40 +04:00
|
|
|
printf("%s", _("Skipping journal creation in super-only mode\n"));
|
2009-03-31 15:42:24 +04:00
|
|
|
fs->super->s_journal_inum = EXT2_JOURNAL_INO;
|
|
|
|
goto no_journal;
|
|
|
|
}
|
|
|
|
|
2001-02-17 09:09:50 +03:00
|
|
|
if (!journal_blocks) {
|
|
|
|
fs->super->s_feature_compat &=
|
|
|
|
~EXT3_FEATURE_COMPAT_HAS_JOURNAL;
|
|
|
|
goto no_journal;
|
|
|
|
}
|
|
|
|
if (!quiet) {
|
2007-08-04 02:56:01 +04:00
|
|
|
printf(_("Creating journal (%u blocks): "),
|
2000-12-31 06:21:56 +03:00
|
|
|
journal_blocks);
|
2001-02-17 09:09:50 +03:00
|
|
|
fflush(stdout);
|
|
|
|
}
|
2014-01-28 21:58:56 +04:00
|
|
|
retval = ext2fs_add_journal_inode2(fs, journal_blocks,
|
|
|
|
journal_location,
|
|
|
|
journal_flags);
|
2000-10-24 23:33:45 +04:00
|
|
|
if (retval) {
|
2013-12-16 07:11:40 +04:00
|
|
|
com_err(program_name, retval, "%s",
|
|
|
|
_("\n\twhile trying to create journal"));
|
2000-10-24 23:33:45 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
if (!quiet)
|
2013-12-16 07:11:40 +04:00
|
|
|
printf("%s", _("done\n"));
|
2000-10-24 23:33:45 +04:00
|
|
|
}
|
2001-02-17 09:09:50 +03:00
|
|
|
no_journal:
|
2011-09-24 21:48:55 +04:00
|
|
|
if (!super_only &&
|
|
|
|
fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_MMP) {
|
|
|
|
retval = ext2fs_mmp_init(fs);
|
|
|
|
if (retval) {
|
2013-12-16 07:11:40 +04:00
|
|
|
fprintf(stderr, "%s",
|
|
|
|
_("\nError while enabling multiple "
|
|
|
|
"mount protection feature."));
|
2011-09-24 21:48:55 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
if (!quiet)
|
|
|
|
printf(_("Multiple mount protection is enabled "
|
|
|
|
"with update interval %d seconds.\n"),
|
|
|
|
fs->super->s_mmp_update_interval);
|
|
|
|
}
|
2001-02-17 09:09:50 +03:00
|
|
|
|
2011-06-11 02:57:22 +04:00
|
|
|
if (EXT2_HAS_RO_COMPAT_FEATURE(&fs_param,
|
|
|
|
EXT4_FEATURE_RO_COMPAT_BIGALLOC))
|
|
|
|
fix_cluster_bg_counts(fs);
|
2011-07-20 22:40:04 +04:00
|
|
|
if (EXT2_HAS_RO_COMPAT_FEATURE(&fs_param,
|
|
|
|
EXT4_FEATURE_RO_COMPAT_QUOTA))
|
|
|
|
create_quota_inodes(fs);
|
|
|
|
|
2014-01-21 08:06:07 +04:00
|
|
|
retval = mk_hugefiles(fs);
|
|
|
|
if (retval)
|
|
|
|
com_err(program_name, retval, "while creating huge files");
|
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
if (!quiet)
|
2013-12-16 07:11:40 +04:00
|
|
|
printf("%s", _("Writing superblocks and "
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
"filesystem accounting information: "));
|
2011-09-14 06:24:11 +04:00
|
|
|
checkinterval = fs->super->s_checkinterval;
|
|
|
|
max_mnt_count = fs->super->s_max_mnt_count;
|
2014-07-06 05:06:29 +04:00
|
|
|
retval = ext2fs_close_free(&fs);
|
1999-03-16 22:35:19 +03:00
|
|
|
if (retval) {
|
2013-12-16 07:11:40 +04:00
|
|
|
fprintf(stderr, "%s",
|
2002-03-08 08:14:46 +03:00
|
|
|
_("\nWarning, had trouble writing out superblocks."));
|
2011-09-14 06:24:11 +04:00
|
|
|
} else if (!quiet) {
|
2013-12-16 07:11:40 +04:00
|
|
|
printf("%s", _("done\n\n"));
|
2003-09-01 17:28:18 +04:00
|
|
|
if (!getenv("MKE2FS_SKIP_CHECK_MSG"))
|
2011-09-14 06:24:11 +04:00
|
|
|
print_check_message(max_mnt_count, checkinterval);
|
2001-02-17 09:09:50 +03:00
|
|
|
}
|
2011-09-14 06:24:11 +04:00
|
|
|
|
2006-12-26 11:38:07 +03:00
|
|
|
remove_error_table(&et_ext2_error_table);
|
|
|
|
remove_error_table(&et_prof_error_table);
|
2008-02-19 16:32:58 +03:00
|
|
|
profile_release(profile);
|
2010-12-02 02:49:26 +03:00
|
|
|
for (i=0; fs_types[i]; i++)
|
|
|
|
free(fs_types[i]);
|
|
|
|
free(fs_types);
|
2011-09-14 06:24:11 +04:00
|
|
|
return retval;
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|