+2001-01-01 <tytso@snap.thunk.org>
+
+ * debugfs.c Replace use of struct ext2fs_sb with struct
+ ext2_super_block.
+
2000-12-30 <tytso@snap.thunk.org>
* dump.c (fix_perms): Fix bug for systems which don't have fchown;
return;
}
-static void print_features(struct ext2fs_sb * s, FILE *f)
+static void print_features(struct ext2_super_block * s, FILE *f)
{
-#ifdef EXT2_DYNAMIC_REV
int i, j, printed=0;
__u32 *mask = &s->s_feature_compat, m;
if (printed == 0)
printf("(none)");
printf("\n");
-#endif
}
void do_show_super_stats(int argc, char *argv[])
{
int i;
FILE *out;
- struct ext2fs_sb *sb;
struct ext2_group_desc *gdp;
int c, header_only = 0;
char buf[80];
else
ext2fs_mark_super_dirty(current_fs);
}
- print_features((struct ext2fs_sb *) current_fs->super, stdout);
+ print_features(current_fs->super, stdout);
}
static int source_file(const char *cmd_file, int sci_idx)
2001-01-01 <tytso@snap.thunk.org>
+ * journal.c, pass1.c, super.c, unix.c: Replace use of struct
+ ext2fs_sb with struct ext2_super_block.
+
* pass1.c (check_blocks): Remove use of EXT2_HAS_*_FEATURE macros.
2000-12-31 <tytso@snap.thunk.org>
static void e2fsck_clear_recover(e2fsck_t ctx, int error)
{
- struct ext2fs_sb *s = (struct ext2fs_sb *)ctx->fs->super;
-
- s->s_feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER;
+ ctx->fs->super->s_feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER;
/* if we had an error doing journal recovery, we need a full fsck */
if (error)
- s->s_state &= ~EXT2_VALID_FS;
+ ctx->fs->super->s_state &= ~EXT2_VALID_FS;
ext2fs_mark_super_dirty(ctx->fs);
}
-static int e2fsck_journal_init_inode(e2fsck_t ctx, struct ext2fs_sb *s,
+static int e2fsck_journal_init_inode(e2fsck_t ctx,
+ struct ext2_super_block *s,
ino_t journal_inum, journal_t **journal)
{
struct inode *inode;
{
char uuid_str[40];
struct problem_context pctx;
- struct ext2fs_sb *s = (struct ext2fs_sb *)ctx->fs->super;
- int recover = s->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER;
+ struct ext2_super_block *sb = ctx->fs->super;
+ int recover = ctx->fs->super->s_feature_incompat &
+ EXT3_FEATURE_INCOMPAT_RECOVER;
clear_problem_context(&pctx);
- if (s->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) {
- if (s->s_journal_dev) {
- pctx.num = s->s_journal_dev;
+ if (sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) {
+ if (sb->s_journal_dev) {
+ pctx.num = sb->s_journal_dev;
/* this problem aborts on -y, -p, unsupported on -n */
if (!fix_problem(ctx, PR_0_JOURNAL_UNSUPP_DEV, &pctx))
return EXT2_ET_UNSUPP_FEATURE;
- s->s_journal_dev = 0;
- s->s_state &= ~EXT2_VALID_FS;
+ sb->s_journal_dev = 0;
+ sb->s_state &= ~EXT2_VALID_FS;
ext2fs_mark_super_dirty(ctx->fs);
}
- if (!uuid_is_null(s->s_journal_uuid)) {
- uuid_unparse(s->s_journal_uuid, uuid_str);
+ if (!uuid_is_null(sb->s_journal_uuid)) {
+ uuid_unparse(sb->s_journal_uuid, uuid_str);
pctx.str = uuid_str;
/* this problem aborts on -y, -p, unsupported on -n */
if (!fix_problem(ctx, PR_0_JOURNAL_UNSUPP_UUID, &pctx))
return EXT2_ET_UNSUPP_FEATURE;
- uuid_clear(s->s_journal_uuid);
- s->s_state &= ~EXT2_VALID_FS;
+ uuid_clear(sb->s_journal_uuid);
+ sb->s_state &= ~EXT2_VALID_FS;
ext2fs_mark_super_dirty(ctx->fs);
}
- if (!s->s_journal_inum)
+ if (!sb->s_journal_inum)
return EXT2_ET_BAD_INODE_NUM;
}
- if (s->s_journal_dev) {
- pctx.num = s->s_journal_dev;
+ if (sb->s_journal_dev) {
+ pctx.num = sb->s_journal_dev;
if (!fix_problem(ctx, PR_0_JOURNAL_BAD_DEV, &pctx))
return EXT2_ET_UNSUPP_FEATURE;
- s->s_journal_dev = 0;
- s->s_state &= ~EXT2_VALID_FS;
+ sb->s_journal_dev = 0;
+ sb->s_state &= ~EXT2_VALID_FS;
ext2fs_mark_super_dirty(ctx->fs);
}
- if (!uuid_is_null(s->s_journal_uuid)) {
- uuid_unparse(s->s_journal_uuid, uuid_str);
+ if (!uuid_is_null(sb->s_journal_uuid)) {
+ uuid_unparse(sb->s_journal_uuid, uuid_str);
pctx.str = uuid_str;
if (!fix_problem(ctx, PR_0_JOURNAL_BAD_UUID, &pctx))
return EXT2_ET_UNSUPP_FEATURE;
- uuid_clear(s->s_journal_uuid);
- s->s_state &= ~EXT2_VALID_FS;
+ uuid_clear(sb->s_journal_uuid);
+ sb->s_state &= ~EXT2_VALID_FS;
ext2fs_mark_super_dirty(ctx->fs);
}
- return e2fsck_journal_init_inode(ctx, s, s->s_journal_inum, journal);
+ return e2fsck_journal_init_inode(ctx, sb, sb->s_journal_inum, journal);
}
static int e2fsck_journal_fix_bad_inode(e2fsck_t ctx,
struct problem_context *pctx)
{
- struct ext2fs_sb *s = (struct ext2fs_sb *)ctx->fs->super;
- int recover = s->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER;
- int has_journal = s->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL;
+ struct ext2_super_block *sb = ctx->fs->super;
+ int recover = ctx->fs->super->s_feature_incompat &
+ EXT3_FEATURE_INCOMPAT_RECOVER;
+ int has_journal = ctx->fs->super->s_feature_compat &
+ EXT3_FEATURE_COMPAT_HAS_JOURNAL;
- if (has_journal || s->s_journal_inum) {
+ if (has_journal || sb->s_journal_inum) {
/* The journal inode is bogus, remove and force full fsck */
if (fix_problem(ctx, PR_0_JOURNAL_BAD_INODE, pctx)) {
- struct ext2fs_sb *s =(struct ext2fs_sb *)ctx->fs->super;
-
- if (has_journal && s->s_journal_inum)
+ if (has_journal && sb->s_journal_inum)
printf("*** ext3 journal has been deleted - "
"filesystem is now ext2 only ***\n\n");
- s->s_feature_compat &= ~EXT3_FEATURE_COMPAT_HAS_JOURNAL;
- s->s_journal_inum = 0;
+ sb->s_feature_compat &= ~EXT3_FEATURE_COMPAT_HAS_JOURNAL;
+ sb->s_journal_inum = 0;
e2fsck_clear_recover(ctx, 1);
return 0;
}
static int e2fsck_journal_fix_unsupported_super(e2fsck_t ctx,
struct problem_context *pctx)
{
- struct ext2fs_sb *s = (struct ext2fs_sb *)ctx->fs->super;
+ struct ext2_super_block *sb = ctx->fs->super;
/* Unsupported journal superblock - first choice is abort.
* Declining that gives the option to reset the superblock.
* Otherwise we get the chance to delete the journal, and
* failing that we abort because we can't handle this.
*/
- if (s->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL &&
+ if (sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL &&
fix_problem(ctx, PR_0_JOURNAL_UNSUPP_SUPER, pctx))
return EXT2_ET_CORRUPT_SUPERBLOCK;
static int e2fsck_journal_fix_corrupt_super(e2fsck_t ctx, journal_t *journal,
struct problem_context *pctx)
{
- struct ext2fs_sb *s = (struct ext2fs_sb *)ctx->fs->super;
- int recover = s->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER;
+ struct ext2_super_block *sb = ctx->fs->super;
+ int recover = ctx->fs->super->s_feature_incompat &
+ EXT3_FEATURE_INCOMPAT_RECOVER;
pctx->num = journal->j_inode->i_ino;
- if (s->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) {
+ if (sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) {
if (fix_problem(ctx, PR_0_JOURNAL_BAD_SUPER, pctx)) {
e2fsck_journal_reset_super(ctx, journal->j_superblock,
journal);
*/
int e2fsck_check_ext3_journal(e2fsck_t ctx)
{
- struct ext2fs_sb *s = (struct ext2fs_sb *)ctx->fs->super;
+ struct ext2_super_block *sb = ctx->fs->super;
journal_t *journal;
- int recover = s->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER;
+ int recover = ctx->fs->super->s_feature_incompat &
+ EXT3_FEATURE_INCOMPAT_RECOVER;
struct problem_context pctx;
int reset = 0;
int retval;
/* If we don't have any journal features, don't do anything more */
- if (!(s->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) &&
- !recover && s->s_journal_inum == 0 && s->s_journal_dev == 0 &&
- uuid_is_null(s->s_journal_uuid))
+ if (!(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) &&
+ !recover && sb->s_journal_inum == 0 && sb->s_journal_dev == 0 &&
+ uuid_is_null(sb->s_journal_uuid))
return 0;
#ifdef JFS_DEBUG
journal_enable_debug = 2;
#endif
clear_problem_context(&pctx);
- pctx.num = s->s_journal_inum;
+ pctx.num = sb->s_journal_inum;
retval = e2fsck_get_journal(ctx, &journal);
if (retval) {
* with -y, -n, or -p, only if a user isn't making up their mind.
*/
no_has_journal:
- if (!(s->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL)) {
- recover = s->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER;
+ if (!(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL)) {
+ recover = sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER;
pctx.str = "inode";
if (fix_problem(ctx, PR_0_JOURNAL_HAS_JOURNAL, &pctx)) {
if (recover &&
!fix_problem(ctx, PR_0_JOURNAL_RECOVER_SET, &pctx))
goto no_has_journal;
- s->s_journal_inum = 0;
+ sb->s_journal_inum = 0;
e2fsck_clear_recover(ctx, recover);
} else if (!(ctx->options & E2F_OPT_READONLY)) {
- s->s_feature_compat |= EXT3_FEATURE_COMPAT_HAS_JOURNAL;
+ sb->s_feature_compat |= EXT3_FEATURE_COMPAT_HAS_JOURNAL;
ext2fs_mark_super_dirty(ctx->fs);
}
}
- if (s->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL &&
- !(s->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) &&
+ if (sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL &&
+ !(sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) &&
journal->j_superblock->s_start != 0) {
if (fix_problem(ctx, PR_0_JOURNAL_RESET_JOURNAL, &pctx))
reset = 1;
unsigned char frag, fsize;
struct problem_context pctx;
struct scan_callback_struct scan_struct;
- struct ext2fs_sb *sb;
+ struct ext2_super_block *sb = ctx->fs->super;
int imagic_fs;
#ifdef RESOURCE_TRACK
}
#undef EXT2_BPP
- sb = (struct ext2fs_sb *) fs->super;
imagic_fs = (sb->s_feature_compat & EXT2_FEATURE_COMPAT_IMAGIC_INODES);
/*
struct ext2_inode *inode = pctx->inode;
int bad_size = 0;
__u64 size;
- struct ext2fs_sb *sb;
if (!ext2fs_inode_has_valid_blocks(pctx->inode))
return;
((inode->i_size & (fs->blocksize-1)) != 0))
bad_size = 1;
else if (nblock < (pb.last_block + 1)) {
- sb = (struct ext2fs_sb *) fs->super;
if (((pb.last_block + 1) - nblock) >
- sb->s_prealloc_dir_blocks)
+ fs->super->s_prealloc_dir_blocks)
bad_size = 2;
}
} else {
{
ext2_filsys fs = ctx->fs;
blk_t first_block, last_block;
- struct ext2fs_sb *s = (struct ext2fs_sb *) fs->super;
+ struct ext2_super_block *sb = fs->super;
blk_t blocks_per_group = fs->super->s_blocks_per_group;
int inodes_per_block;
dgrp_t i;
/*
* Verify the super block constants...
*/
- check_super_value(ctx, "inodes_count", s->s_inodes_count,
+ check_super_value(ctx, "inodes_count", sb->s_inodes_count,
MIN_CHECK, 1, 0);
- check_super_value(ctx, "blocks_count", s->s_blocks_count,
+ check_super_value(ctx, "blocks_count", sb->s_blocks_count,
MIN_CHECK, 1, 0);
- check_super_value(ctx, "first_data_block", s->s_first_data_block,
- MAX_CHECK, 0, s->s_blocks_count);
- check_super_value(ctx, "log_frag_size", s->s_log_frag_size,
+ check_super_value(ctx, "first_data_block", sb->s_first_data_block,
+ MAX_CHECK, 0, sb->s_blocks_count);
+ check_super_value(ctx, "log_frag_size", sb->s_log_frag_size,
MAX_CHECK, 0, 2);
- check_super_value(ctx, "log_block_size", s->s_log_block_size,
- MIN_CHECK | MAX_CHECK, s->s_log_frag_size,
+ check_super_value(ctx, "log_block_size", sb->s_log_block_size,
+ MIN_CHECK | MAX_CHECK, sb->s_log_frag_size,
2);
- check_super_value(ctx, "frags_per_group", s->s_frags_per_group,
- MIN_CHECK | MAX_CHECK, 1, 8 * EXT2_BLOCK_SIZE(s));
- check_super_value(ctx, "blocks_per_group", s->s_blocks_per_group,
- MIN_CHECK | MAX_CHECK, 1, 8 * EXT2_BLOCK_SIZE(s));
- check_super_value(ctx, "inodes_per_group", s->s_inodes_per_group,
+ check_super_value(ctx, "frags_per_group", sb->s_frags_per_group,
+ MIN_CHECK | MAX_CHECK, 1, 8 * EXT2_BLOCK_SIZE(sb));
+ check_super_value(ctx, "blocks_per_group", sb->s_blocks_per_group,
+ MIN_CHECK | MAX_CHECK, 1, 8 * EXT2_BLOCK_SIZE(sb));
+ check_super_value(ctx, "inodes_per_group", sb->s_inodes_per_group,
MIN_CHECK | MAX_CHECK, 1,
inodes_per_block * blocks_per_group);
- check_super_value(ctx, "r_blocks_count", s->s_r_blocks_count,
- MAX_CHECK, 0, s->s_blocks_count);
+ check_super_value(ctx, "r_blocks_count", sb->s_r_blocks_count,
+ MAX_CHECK, 0, sb->s_blocks_count);
if (!ctx->num_blocks) {
pctx.errcode = e2fsck_get_device_size(ctx);
return;
}
if ((pctx.errcode != EXT2_ET_UNIMPLEMENTED) &&
- (ctx->num_blocks < s->s_blocks_count)) {
- pctx.blk = s->s_blocks_count;
+ (ctx->num_blocks < sb->s_blocks_count)) {
+ pctx.blk = sb->s_blocks_count;
pctx.blk2 = ctx->num_blocks;
if (fix_problem(ctx, PR_0_FS_SIZE_WRONG, &pctx)) {
ctx->flags |= E2F_FLAG_ABORT;
}
}
- if (s->s_log_block_size != s->s_log_frag_size) {
- pctx.blk = EXT2_BLOCK_SIZE(s);
- pctx.blk2 = EXT2_FRAG_SIZE(s);
+ if (sb->s_log_block_size != sb->s_log_frag_size) {
+ pctx.blk = EXT2_BLOCK_SIZE(sb);
+ pctx.blk2 = EXT2_FRAG_SIZE(sb);
fix_problem(ctx, PR_0_NO_FRAGMENTS, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
return;
}
- should_be = s->s_frags_per_group >>
- (s->s_log_block_size - s->s_log_frag_size);
- if (s->s_blocks_per_group != should_be) {
- pctx.blk = s->s_blocks_per_group;
+ should_be = sb->s_frags_per_group >>
+ (sb->s_log_block_size - sb->s_log_frag_size);
+ if (sb->s_blocks_per_group != should_be) {
+ pctx.blk = sb->s_blocks_per_group;
pctx.blk2 = should_be;
fix_problem(ctx, PR_0_BLOCKS_PER_GROUP, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
return;
}
- should_be = (s->s_log_block_size == 0) ? 1 : 0;
- if (s->s_first_data_block != should_be) {
- pctx.blk = s->s_first_data_block;
+ should_be = (sb->s_log_block_size == 0) ? 1 : 0;
+ if (sb->s_first_data_block != should_be) {
+ pctx.blk = sb->s_first_data_block;
pctx.blk2 = should_be;
fix_problem(ctx, PR_0_FIRST_DATA_BLOCK, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
return;
}
- should_be = s->s_inodes_per_group * fs->group_desc_count;
- if (s->s_inodes_count != should_be) {
- pctx.ino = s->s_inodes_count;
+ should_be = sb->s_inodes_per_group * fs->group_desc_count;
+ if (sb->s_inodes_count != should_be) {
+ pctx.ino = sb->s_inodes_count;
pctx.ino2 = should_be;
if (fix_problem(ctx, PR_0_INODE_COUNT_WRONG, &pctx)) {
- s->s_inodes_count = should_be;
+ sb->s_inodes_count = should_be;
ext2fs_mark_super_dirty(fs);
}
}
/*
* If the UUID field isn't assigned, assign it.
*/
- if (!(ctx->options & E2F_OPT_READONLY) && uuid_is_null(s->s_uuid)) {
+ if (!(ctx->options & E2F_OPT_READONLY) && uuid_is_null(sb->s_uuid)) {
if (fix_problem(ctx, PR_0_ADD_UUID, &pctx)) {
- uuid_generate(s->s_uuid);
+ uuid_generate(sb->s_uuid);
ext2fs_mark_super_dirty(fs);
}
}
int i;
ext2_filsys fs = 0;
io_manager io_ptr;
- struct ext2fs_sb *s;
+ struct ext2_super_block *sb;
const char *lib_ver_date;
int my_ver, lib_ver;
e2fsck_t ctx;
}
ctx->fs = fs;
fs->priv_data = ctx;
-#ifdef EXT2_CURRENT_REV
- if (fs->super->s_rev_level > E2FSCK_CURRENT_REV) {
+ sb = fs->super;
+ if (sb->s_rev_level > E2FSCK_CURRENT_REV) {
com_err(ctx->program_name, EXT2_ET_REV_TOO_HIGH,
_("while trying to open %s"),
ctx->filesystem_name);
get_newer:
fatal_error(ctx, _("Get a newer version of e2fsck!"));
}
-#endif
- s = (struct ext2fs_sb *) fs->super;
/*
* Set the device name, which is used whenever we print error
* or informational messages to the user.
*/
if (ctx->device_name == 0 &&
- (s->s_volume_name[0] != 0)) {
- char *cp = malloc(sizeof(s->s_volume_name)+1);
+ (sb->s_volume_name[0] != 0)) {
+ char *cp = malloc(sizeof(sb->s_volume_name)+1);
if (cp) {
- strncpy(cp, s->s_volume_name,
- sizeof(s->s_volume_name));
- cp[sizeof(s->s_volume_name)] = 0;
+ strncpy(cp, sb->s_volume_name,
+ sizeof(sb->s_volume_name));
+ cp[sizeof(sb->s_volume_name)] = 0;
ctx->device_name = cp;
}
}
* Check to see if we need to do ext3-style recovery. If so,
* do it, and then restart the fsck.
*/
- if (s->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) {
+ if (sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) {
if (ctx->options & E2F_OPT_READONLY) {
printf(_("Warning: skipping journal recovery "
"because doing a read-only filesystem "
* Check for compatibility with the feature sets. We need to
* be more stringent than ext2fs_open().
*/
- if ((s->s_feature_compat & ~EXT2_LIB_FEATURE_COMPAT_SUPP) ||
- (s->s_feature_incompat & ~EXT2_LIB_FEATURE_INCOMPAT_SUPP)) {
+ if ((sb->s_feature_compat & ~EXT2_LIB_FEATURE_COMPAT_SUPP) ||
+ (sb->s_feature_incompat & ~EXT2_LIB_FEATURE_INCOMPAT_SUPP)) {
com_err(ctx->program_name, EXT2_ET_UNSUPP_FEATURE,
"(%s)", ctx->device_name);
goto get_newer;
}
- if (s->s_feature_ro_compat & ~EXT2_LIB_FEATURE_RO_COMPAT_SUPP) {
+ if (sb->s_feature_ro_compat & ~EXT2_LIB_FEATURE_RO_COMPAT_SUPP) {
com_err(ctx->program_name, EXT2_ET_RO_UNSUPP_FEATURE,
"(%s)", ctx->device_name);
goto get_newer;
}
#ifdef ENABLE_COMPRESSION
- if (s->s_feature_incompat & EXT2_FEATURE_INCOMPAT_COMPRESSION)
+ if (sb->s_feature_incompat & EXT2_FEATURE_INCOMPAT_COMPRESSION)
com_err(ctx->program_name, 0,
_("Warning: compression support is experimental.\n"));
#endif
exit_value = FSCK_UNCORRECTED;
if (!(ctx->options & E2F_OPT_READONLY)) {
if (ext2fs_test_valid(fs)) {
- if (!(fs->super->s_state & EXT2_VALID_FS))
+ if (!(sb->s_state & EXT2_VALID_FS))
exit_value = FSCK_NONDESTRUCT;
- fs->super->s_state = EXT2_VALID_FS;
+ sb->s_state = EXT2_VALID_FS;
} else
- fs->super->s_state &= ~EXT2_VALID_FS;
- fs->super->s_mnt_count = 0;
- fs->super->s_lastcheck = time(NULL);
+ sb->s_state &= ~EXT2_VALID_FS;
+ sb->s_mnt_count = 0;
+ sb->s_lastcheck = time(NULL);
ext2fs_mark_super_dirty(fs);
}
show_stats(ctx);
git://git.whamcloud.com / tools / e2fsprogs.git / commitdiff