/*
- * tune2fs.c - Change the file system parameters on
- * an unmounted second extended file system
+ * tune2fs.c - Change the file system parameters on an ext2 file system
*
* Copyright (C) 1992, 1993, 1994 Remy Card <card@masi.ibp.fr>
* Laboratoire MASI, Institut Blaise Pascal
* Universite Pierre et Marie Curie (Paris VI)
*
- * Copyright 1995, 1996, 1997 by Theodore Ts'o.
+ * Copyright 1995, 1996, 1997, 1998, 1999, 2000 by Theodore Ts'o.
*
* %Begin-Header%
* This file may be redistributed under the terms of the GNU Public
#include <unistd.h>
#include <sys/types.h>
-#include <linux/ext2_fs.h>
-
+#include "ext2fs/ext2_fs.h"
#include "ext2fs/ext2fs.h"
#include "et/com_err.h"
#include "uuid/uuid.h"
#include "e2p/e2p.h"
+#include "jfs_user.h"
#include "util.h"
+#include "get_device_by_label.h"
#include "../version.h"
#include "nls-enable.h"
const char * program_name = "tune2fs";
char * device_name;
-char * new_label, *new_last_mounted, *new_UUID, *journal_opts;
-static int c_flag, C_flag, e_flag, g_flag, i_flag, l_flag, L_flag;
+char * new_label, *new_last_mounted, *new_UUID;
+static int c_flag, C_flag, e_flag, f_flag, g_flag, i_flag, l_flag, L_flag;
static int m_flag, M_flag, r_flag, s_flag = -1, u_flag, U_flag;
+static int print_label;
static int max_mount_count, mount_count, mount_flags;
static unsigned long interval, reserved_ratio, reserved_blocks;
static unsigned long resgid, resuid;
static unsigned short errors;
+static int open_flag;
+static char *features_cmd;
int journal_size, journal_flags;
char *journal_device;
fprintf(stderr,
_("Usage: %s [-c max-mounts-count] [-e errors-behavior] "
"[-g group]\n"
- "\t[-i interval[d|m|w]] [-j journal-options]\n"
+ "\t[-i interval[d|m|w]] [-j] [-J journal-options]\n"
"\t[-l] [-s sparse-flag] [-m reserved-blocks-percent]\n"
"\t[-r reserved-blocks-count] [-u user] [-C mount-count]\n"
"\t[-L volume-label] [-M last-mounted-dir] [-U UUID]\n"
};
/*
+ * Remove an external journal from the filesystem
+ */
+static void remove_journal_device(ext2_filsys fs)
+{
+ char *journal_device;
+ ext2_filsys jfs;
+ char buf[1024];
+ journal_superblock_t *jsb;
+ int i, nr_users;
+ errcode_t retval;
+ int commit_remove_journal = 0;
+
+ if (f_flag)
+ commit_remove_journal = 1; /* force removal even if error */
+
+ uuid_unparse(fs->super->s_journal_uuid, buf);
+ journal_device = get_spec_by_uuid(buf);
+
+ if (!journal_device) {
+ journal_device =
+ ext2fs_find_block_device(fs->super->s_journal_dev);
+ if (!journal_device)
+ return;
+ }
+
+ 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 external journal"));
+ goto no_valid_journal;
+ }
+ if (!(jfs->super->s_feature_incompat & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) {
+ fprintf(stderr, _("%s is not a journal device.\n"),
+ journal_device);
+ goto no_valid_journal;
+ }
+
+ /* Get the journal superblock */
+ if ((retval = io_channel_read_blk(jfs->io, 1, -1024, buf))) {
+ com_err(program_name, retval,
+ _("while reading journal superblock"));
+ goto no_valid_journal;
+ }
+
+ jsb = (journal_superblock_t *) buf;
+ if ((jsb->s_header.h_magic != (unsigned) ntohl(JFS_MAGIC_NUMBER)) ||
+ (jsb->s_header.h_blocktype != (unsigned) ntohl(JFS_SUPERBLOCK_V2))) {
+ fprintf(stderr, _("Journal superblock not found!\n"));
+ goto no_valid_journal;
+ }
+
+ /* Find the filesystem UUID */
+ nr_users = ntohl(jsb->s_nr_users);
+ for (i=0; i < nr_users; i++) {
+ if (memcmp(fs->super->s_uuid,
+ &jsb->s_users[i*16], 16) == 0)
+ break;
+ }
+ if (i >= nr_users) {
+ fprintf(stderr,
+ _("Filesystem's UUID not found on journal device.\n"));
+ commit_remove_journal = 1;
+ goto no_valid_journal;
+ }
+ nr_users--;
+ for (i=0; i < nr_users; i++)
+ memcpy(&jsb->s_users[i*16], &jsb->s_users[(i+1)*16], 16);
+ jsb->s_nr_users = htonl(nr_users);
+
+ /* Write back the journal superblock */
+ if ((retval = io_channel_write_blk(jfs->io, 1, -1024, buf))) {
+ com_err(program_name, retval,
+ "while writing journal superblock.");
+ goto no_valid_journal;
+ }
+
+ commit_remove_journal = 1;
+
+no_valid_journal:
+ if (commit_remove_journal == 0) {
+ fprintf(stderr, _("Journal NOT removed\n"));
+ exit(1);
+ }
+ fs->super->s_journal_dev = 0;
+ memset(fs->super->s_journal_uuid, 0,
+ sizeof(fs->super->s_journal_uuid));
+ ext2fs_mark_super_dirty(fs);
+ printf(_("Journal removed\n"));
+ free(journal_device);
+}
+
+/* Helper function for remove_journal_inode */
+static int release_blocks_proc(ext2_filsys fs, blk_t *blocknr,
+ int blockcnt, void *private)
+{
+ blk_t block;
+ int group;
+
+ block = *blocknr;
+ ext2fs_unmark_block_bitmap(fs->block_map,block);
+ group = ext2fs_group_of_blk(fs, block);
+ fs->group_desc[group].bg_free_blocks_count++;
+ fs->super->s_free_blocks_count++;
+ return 0;
+}
+
+/*
+ * Remove the journal inode from the filesystem
+ */
+static void remove_journal_inode(ext2_filsys fs)
+{
+ struct ext2_inode inode;
+ errcode_t retval;
+ ino_t ino = fs->super->s_journal_inum;
+ int group;
+
+ retval = ext2fs_read_inode(fs, ino, &inode);
+ if (retval) {
+ com_err(program_name, retval,
+ _("while reading journal inode"));
+ exit(1);
+ }
+ if (ino == EXT2_JOURNAL_INO) {
+ retval = ext2fs_read_bitmaps(fs);
+ if (retval) {
+ com_err(program_name, retval,
+ _("while reading bitmaps"));
+ exit(1);
+ }
+ retval = ext2fs_block_iterate(fs, ino, 0, NULL,
+ release_blocks_proc, NULL);
+ if (retval) {
+ com_err(program_name, retval,
+ _("while clearing journal inode"));
+ exit(1);
+ }
+ memset(&inode, 0, sizeof(inode));
+ ext2fs_mark_bb_dirty(fs);
+ group = ext2fs_group_of_ino(fs, ino);
+ fs->flags &= ~EXT2_FLAG_SUPER_ONLY;
+ } else
+ inode.i_flags &= ~EXT2_IMMUTABLE_FL;
+ retval = ext2fs_write_inode(fs, ino, &inode);
+ if (retval) {
+ com_err(program_name, retval,
+ _("while writing journal inode"));
+ exit(1);
+ }
+ fs->super->s_journal_inum = 0;
+ ext2fs_mark_super_dirty(fs);
+}
+
+/*
* Update the feature set as provided by the user.
*/
-static void update_feature_set(ext2_filsys fs, char *features_cmd)
+static void update_feature_set(ext2_filsys fs, char *features)
{
int sparse, old_sparse, filetype, old_filetype;
int journal, old_journal;
EXT2_FEATURE_INCOMPAT_FILETYPE;
old_journal = sb->s_feature_compat &
EXT3_FEATURE_COMPAT_HAS_JOURNAL;
- if (e2p_edit_feature(features_cmd, &sb->s_feature_compat,
+ if (e2p_edit_feature(features, &sb->s_feature_compat,
ok_features)) {
fprintf(stderr, _("Invalid filesystem option set: %s\n"),
- features_cmd);
+ features);
exit(1);
}
sparse = sb->s_feature_ro_compat &
if ((mount_flags & EXT2_MF_MOUNTED) &&
!(mount_flags & EXT2_MF_READONLY)) {
fprintf(stderr,
- _("The HAS_JOURNAL flag may only be "
+ _("The has_journal flag may only be "
"cleared when the filesystem is\n"
"unmounted or mounted "
"read-only.\n"));
if (sb->s_feature_incompat &
EXT3_FEATURE_INCOMPAT_RECOVER) {
fprintf(stderr,
- _("The NEEDS_RECOVERY flag is set. "
+ _("The needs_recovery flag is set. "
"Please run e2fsck before clearing\n"
- "the HAS_JOURNAL flag.\n"));
+ "the has_journal flag.\n"));
exit(1);
}
- /*
- * Remove the immutable flag on the journal inode
- */
if (sb->s_journal_inum) {
- retval = ext2fs_read_inode(fs, sb->s_journal_inum,
- &inode);
- if (retval) {
- com_err(program_name, retval,
- "while reading journal inode");
- exit(1);
- }
- inode.i_flags &= ~EXT2_IMMUTABLE_FL;
- retval = ext2fs_write_inode(fs, sb->s_journal_inum,
- &inode);
- if (retval) {
- com_err(program_name, retval,
- "while write journal inode");
- exit(1);
- }
+ remove_journal_inode(fs);
+ }
+ if (sb->s_journal_dev) {
+ remove_journal_device(fs);
}
}
if (journal && !old_journal) {
* creating the journal. We supply a default size if
* necessary.
*/
- if (!journal_opts)
- journal_opts = "size=16";
- sb->s_feature_compat &=~EXT3_FEATURE_COMPAT_HAS_JOURNAL;
- journal = old_journal;
+ if (!journal_size)
+ journal_size = -1;
+ sb->s_feature_compat &= ~EXT3_FEATURE_COMPAT_HAS_JOURNAL;
}
-
+
if (sb->s_rev_level == EXT2_GOOD_OLD_REV &&
(sb->s_feature_compat || sb->s_feature_ro_compat ||
sb->s_feature_incompat))
ext2fs_update_dynamic_rev(fs);
if ((sparse != old_sparse) ||
- (filetype != old_filetype) ||
- (journal != old_journal)) {
+ (filetype != old_filetype)) {
sb->s_state &= ~EXT2_VALID_FS;
printf("\n%s\n", _(please_fsck));
}
{
unsigned long journal_blocks;
errcode_t retval;
+ ext2_filsys jfs;
if (fs->super->s_feature_compat &
EXT3_FEATURE_COMPAT_HAS_JOURNAL) {
fprintf(stderr, _("The filesystem already has a journal.\n"));
- exit(1);
+ goto err;
}
- parse_journal_opts(journal_opts);
- journal_blocks = journal_size * 1024 / (fs->blocksize / 1024);
if (journal_device) {
check_plausibility(journal_device);
check_mount(journal_device, 0, _("journal"));
+ 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,
+ _("\n\twhile trying to open journal on %s\n"),
+ journal_device);
+ goto err;
+ }
printf(_("Creating journal on device %s: "),
journal_device);
- retval = ext2fs_add_journal_device(fs, journal_device,
- journal_blocks,
- journal_flags);
+ fflush(stdout);
+
+ retval = ext2fs_add_journal_device(fs, jfs);
+ ext2fs_close(jfs);
if (retval) {
com_err (program_name, retval,
- _("while trying to create journal on device %s"),
+ _("while adding filesystem to journal on %s"),
journal_device);
- exit(1);
+ goto err;
}
printf(_("done\n"));
} else if (journal_size) {
- errcode_t retval;
- int mount_flags;
-
printf(_("Creating journal inode: "));
fflush(stdout);
+ journal_blocks = figure_journal_size(journal_size, fs);
+
retval = ext2fs_add_journal_inode(fs, journal_blocks,
journal_flags);
if (retval) {
- printf("\n");
+ fprintf(stderr, "\n");
com_err(program_name, retval,
- _("while trying to create journal"));
+ _("\n\twhile trying to create journal file"));
exit(1);
- }
- printf(_("done\n"));
+ } else
+ printf(_("done\n"));
/*
* If the filesystem wasn't mounted, we need to force
* the block group descriptors out.
if ((mount_flags & EXT2_MF_MOUNTED) == 0)
fs->flags &= ~EXT2_FLAG_SUPER_ONLY;
}
+ print_check_message(fs);
+ return;
+
+err:
+ if (journal_device)
+ free(journal_device);
+ exit(1);
}
+/*
+ * Given argv[0], return the program name.
+ */
+static char *get_progname(char *argv_zero)
+{
+ char *cp;
+ cp = strrchr(argv_zero, '/');
+ if (!cp )
+ return argv_zero;
+ else
+ return cp+1;
+}
-int main (int argc, char ** argv)
+
+static void parse_e2label_options(int argc, char ** argv)
+{
+ if ((argc < 2) || (argc > 3)) {
+ fprintf(stderr, _("Usage: e2label device [newlabel]\n"));
+ exit(1);
+ }
+ device_name = argv[1];
+ if (argc == 3) {
+ open_flag = EXT2_FLAG_RW | EXT2_FLAG_JOURNAL_DEV_OK;
+ L_flag = 1;
+ new_label = argv[2];
+ } else
+ print_label++;
+}
+
+
+static void parse_tune2fs_options(int argc, char **argv)
{
int c;
char * tmp;
- errcode_t retval;
- ext2_filsys fs;
- struct ext2_super_block *sb;
struct group * gr;
struct passwd * pw;
- int open_flag = 0;
- char *features_cmd = 0;
-#ifdef ENABLE_NLS
- setlocale(LC_MESSAGES, "");
- bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
- textdomain(NLS_CAT_NAME);
-#endif
- fprintf (stderr, _("tune2fs %s, %s for EXT2 FS %s, %s\n"),
- E2FSPROGS_VERSION, E2FSPROGS_DATE,
- EXT2FS_VERSION, EXT2FS_DATE);
- if (argc && *argv)
- program_name = *argv;
- initialize_ext2_error_table();
- while ((c = getopt (argc, argv, "c:e:g:i:j:lm:r:s:u:C:L:M:O:U:")) != EOF)
+ printf("tune2fs %s (%s)\n", E2FSPROGS_VERSION, E2FSPROGS_DATE);
+ while ((c = getopt (argc, argv, "c:e:fg:i:jlm:r:s:u:C:J:L:M:O:U:")) != EOF)
switch (c)
{
case 'c':
optarg);
usage();
}
+ if (max_mount_count == 0)
+ max_mount_count = -1;
c_flag = 1;
open_flag = EXT2_FLAG_RW;
break;
e_flag = 1;
open_flag = EXT2_FLAG_RW;
break;
+ case 'f': /* Force */
+ f_flag = 1;
+ break;
case 'g':
resgid = strtoul (optarg, &tmp, 0);
if (*tmp) {
i_flag = 1;
open_flag = EXT2_FLAG_RW;
break;
- case 'l':
- l_flag = 1;
- break;
case 'j':
- journal_opts = optarg;
+ if (!journal_size)
+ journal_size = -1;
open_flag = EXT2_FLAG_RW;
break;
+ case 'J':
+ parse_journal_opts(optarg);
+ open_flag = EXT2_FLAG_RW;
+ break;
+ case 'l':
+ l_flag = 1;
+ break;
case 'L':
new_label = optarg;
L_flag = 1;
- open_flag = EXT2_FLAG_RW;
+ open_flag = EXT2_FLAG_RW |
+ EXT2_FLAG_JOURNAL_DEV_OK;
break;
case 'm':
reserved_ratio = strtoul (optarg, &tmp, 0);
open_flag = EXT2_FLAG_RW;
break;
case 'O':
+ if (features_cmd) {
+ com_err (program_name, 0,
+ _("-O may only be specified once"));
+ usage();
+ }
features_cmd = optarg;
open_flag = EXT2_FLAG_RW;
break;
case 'U':
new_UUID = optarg;
U_flag = 1;
- open_flag = EXT2_FLAG_RW;
+ open_flag = EXT2_FLAG_RW |
+ EXT2_FLAG_JOURNAL_DEV_OK;
break;
default:
usage();
if (!open_flag && !l_flag)
usage();
device_name = argv[optind];
+}
+
+
+
+int main (int argc, char ** argv)
+{
+ errcode_t retval;
+ ext2_filsys fs;
+ struct ext2_super_block *sb;
+
+#ifdef ENABLE_NLS
+ setlocale(LC_MESSAGES, "");
+ bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
+ textdomain(NLS_CAT_NAME);
+#endif
+ if (argc && *argv)
+ program_name = *argv;
+ initialize_ext2_error_table();
+
+ if (strcmp(get_progname(argv[0]), "e2label") == 0)
+ parse_e2label_options(argc, argv);
+ else
+ parse_tune2fs_options(argc, argv);
+
retval = ext2fs_open (device_name, open_flag, 0, 0,
unix_io_manager, &fs);
if (retval) {
com_err (program_name, retval, _("while trying to open %s"),
device_name);
- printf(_("Couldn't find valid filesystem superblock.\n"));
+ fprintf(stderr,
+ _("Couldn't find valid filesystem superblock.\n"));
exit(1);
}
+ sb = fs->super;
+ if (print_label) {
+ /* For e2label emulation */
+ printf("%.*s\n", (int) sizeof(sb->s_volume_name),
+ sb->s_volume_name);
+ exit(0);
+ }
retval = ext2fs_check_if_mounted(device_name, &mount_flags);
if (retval) {
com_err("ext2fs_check_if_mount", retval,
_("while determining whether %s is mounted."),
device_name);
- return;
+ exit(1);
}
- sb = fs->super;
/* Normally we only need to write out the superblock */
fs->flags |= EXT2_FLAG_SUPER_ONLY;
}
if (features_cmd)
update_feature_set(fs, features_cmd);
- if (journal_opts)
+ if (journal_size || journal_device)
add_journal(fs);
if (U_flag) {
- if (strcasecmp(new_UUID, "null") == 0) {
+ if ((strcasecmp(new_UUID, "null") == 0) ||
+ (strcasecmp(new_UUID, "clear") == 0)) {
uuid_clear(sb->s_uuid);
} else if (strcasecmp(new_UUID, "time") == 0) {
uuid_generate_time(sb->s_uuid);
git://git.whamcloud.com / tools / e2fsprogs.git / blobdiff