diff options
| -rw-r--r-- | debugfs/ChangeLog | 5 | ||||
| -rw-r--r-- | debugfs/debugfs.c | 7 | ||||
| -rw-r--r-- | e2fsck/ChangeLog | 3 | ||||
| -rw-r--r-- | e2fsck/journal.c | 106 | ||||
| -rw-r--r-- | e2fsck/pass1.c | 7 | ||||
| -rw-r--r-- | e2fsck/super.c | 66 | ||||
| -rw-r--r-- | e2fsck/unix.c | 38 |
7 files changed, 117 insertions, 115 deletions
diff --git a/debugfs/ChangeLog b/debugfs/ChangeLog index 62ce6ab0..2e4df375 100644 --- a/debugfs/ChangeLog +++ b/debugfs/ChangeLog @@ -1,3 +1,8 @@ +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; diff --git a/debugfs/debugfs.c b/debugfs/debugfs.c index a38b232d..846f6077 100644 --- a/debugfs/debugfs.c +++ b/debugfs/debugfs.c @@ -228,9 +228,8 @@ void do_init_filesys(int argc, char **argv) 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; @@ -246,14 +245,12 @@ __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]; @@ -1464,7 +1461,7 @@ void do_features(int argc, char *argv[]) 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) diff --git a/e2fsck/ChangeLog b/e2fsck/ChangeLog index 700ffa93..2034d371 100644 --- a/e2fsck/ChangeLog +++ b/e2fsck/ChangeLog @@ -1,5 +1,8 @@ 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> diff --git a/e2fsck/journal.c b/e2fsck/journal.c index 8eaa954b..95a45e2a 100644 --- a/e2fsck/journal.c +++ b/e2fsck/journal.c @@ -138,17 +138,16 @@ void wait_on_buffer(struct buffer_head *bh) 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; @@ -210,73 +209,74 @@ static int e2fsck_get_journal(e2fsck_t ctx, journal_t **journal) { 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; } @@ -294,7 +294,7 @@ static int e2fsck_journal_fix_bad_inode(e2fsck_t ctx, 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. @@ -302,7 +302,7 @@ static int e2fsck_journal_fix_unsupported_super(e2fsck_t ctx, * 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; @@ -429,12 +429,13 @@ void e2fsck_journal_reset_super(e2fsck_t ctx, journal_superblock_t *jsb, 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); @@ -473,24 +474,25 @@ static void e2fsck_journal_release(e2fsck_t ctx, journal_t *journal, int reset) */ 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) { @@ -513,23 +515,23 @@ int e2fsck_check_ext3_journal(e2fsck_t ctx) * 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; diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c index df1522af..098988c5 100644 --- a/e2fsck/pass1.c +++ b/e2fsck/pass1.c @@ -196,7 +196,7 @@ void e2fsck_pass1(e2fsck_t ctx) 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 @@ -224,7 +224,6 @@ void e2fsck_pass1(e2fsck_t ctx) } #undef EXT2_BPP - sb = (struct ext2fs_sb *) fs->super; imagic_fs = (sb->s_feature_compat & EXT2_FEATURE_COMPAT_IMAGIC_INODES); /* @@ -823,7 +822,6 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, 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; @@ -909,9 +907,8 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, ((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 { diff --git a/e2fsck/super.c b/e2fsck/super.c index 92eb4604..8b8e04f4 100644 --- a/e2fsck/super.c +++ b/e2fsck/super.c @@ -293,7 +293,7 @@ void check_super_block(e2fsck_t ctx) { 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; @@ -316,26 +316,26 @@ void check_super_block(e2fsck_t ctx) /* * 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); @@ -345,8 +345,8 @@ void check_super_block(e2fsck_t 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; @@ -355,39 +355,39 @@ void check_super_block(e2fsck_t ctx) } } - 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); } } @@ -449,9 +449,9 @@ void check_super_block(e2fsck_t ctx) /* * 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); } } diff --git a/e2fsck/unix.c b/e2fsck/unix.c index c19a2895..a22a19d0 100644 --- a/e2fsck/unix.c +++ b/e2fsck/unix.c @@ -637,7 +637,7 @@ int main (int argc, char *argv[]) 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; @@ -766,28 +766,26 @@ restart: } 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; } } @@ -810,7 +808,7 @@ restart: * 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 " @@ -834,19 +832,19 @@ restart: * 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 @@ -947,13 +945,13 @@ restart: 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); |