vitalif
/
e2fsprogs
mirror of https://github.com/vitalif/e2fsprogs
1
0
Fork 0
Code Issues Releases Wiki Activity

debugfs: clean up feature test macros with predicate functions 

Create separate predicate functions to test/set/clear feature flags,
thereby replacing the wordy old macros.  Furthermore, clean out the
places where we open-coded feature tests.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
debian
Darrick J. Wong 2015-10-24 01:26:35 -04:00 committed by Theodore Ts'o
parent 21e37be65b
commit 4ee2669982
8 changed files with 57 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
contrib/add_ext4_encrypt.c
View File

@ -42,9 +42,8 @@ int main (int argc, char *argv[])
argv[1]);
exit(1);
}
if (!EXT2_HAS_INCOMPAT_FEATURE(fs->super,
EXT4_FEATURE_INCOMPAT_ENCRYPT)) {
fs->super->s_feature_incompat |= EXT4_FEATURE_INCOMPAT_ENCRYPT;
if (!ext2fs_has_feature_encrypt(fs->super)) {
ext2fs_set_feature_encrypt(fs->super);
fs->super->s_encrypt_algos[0] =
EXT4_ENCRYPTION_MODE_AES_256_XTS;
fs->super->s_encrypt_algos[1] =

6
debugfs/debugfs.c
View File

@ -436,8 +436,7 @@ void do_show_super_stats(int argc, char *argv[])
return;
out = open_pager();
if (EXT2_HAS_RO_COMPAT_FEATURE(current_fs->super,
EXT4_FEATURE_RO_COMPAT_BIGALLOC))
if (ext2fs_has_feature_bigalloc(current_fs->super))
units = "cluster";
list_super2(current_fs->super, out);
@ -893,8 +892,7 @@ void internal_dump_inode(FILE *out, const char *prefix,
(struct ext2_inode_large *) inode);
dump_inode_attributes(out, inode_num);
if (current_fs->super->s_creator_os == EXT2_OS_LINUX &&
current_fs->super->s_feature_ro_compat &
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) {
ext2fs_has_feature_metadata_csum(current_fs->super)) {
__u32 crc = inode->i_checksum_lo;
if (is_large_inode &&
large_inode->i_extra_isize >=

91
debugfs/do_journal.c
View File

@ -88,8 +88,7 @@ static errcode_t journal_commit_trans(journal_transaction_t *trans)
commit->h_magic = ext2fs_cpu_to_be32(JFS_MAGIC_NUMBER);
commit->h_blocktype = ext2fs_cpu_to_be32(JFS_COMMIT_BLOCK);
commit->h_sequence = ext2fs_cpu_to_be32(trans->tid);
if (JFS_HAS_COMPAT_FEATURE(trans->journal,
JFS_FEATURE_COMPAT_CHECKSUM)) {
if (jfs_has_feature_checksum(trans->journal)) {
__u32 csum_v1 = ~0;
blk64_t cblk;
@ -149,7 +148,7 @@ static errcode_t journal_commit_trans(journal_transaction_t *trans)
trans->flags &= ~J_TRANS_OPEN;
trans->block++;
trans->fs->super->s_feature_incompat |= EXT3_FEATURE_INCOMPAT_RECOVER;
ext2fs_set_feature_journal_needs_recovery(trans->fs->super);
ext2fs_mark_super_dirty(trans->fs);
error:
if (cbh)
@ -195,8 +194,7 @@ static errcode_t journal_add_revoke_to_trans(journal_transaction_t *trans,
jrb->r_header.h_sequence = ext2fs_cpu_to_be32(trans->tid);
offset = sizeof(*jrb);
if (JFS_HAS_INCOMPAT_FEATURE(trans->journal,
JFS_FEATURE_INCOMPAT_64BIT))
if (jfs_has_feature_64bit(trans->journal))
sz = 8;
else
sz = 4;
@ -229,8 +227,7 @@ static errcode_t journal_add_revoke_to_trans(journal_transaction_t *trans,
goto error;
}
if (JFS_HAS_INCOMPAT_FEATURE(trans->journal,
JFS_FEATURE_INCOMPAT_64BIT))
if (jfs_has_feature_64bit(trans->journal))
*((__u64 *)(&((char *)buf)[offset])) =
ext2fs_cpu_to_be64(revoke_list[i]);
else
@ -364,8 +361,7 @@ static errcode_t journal_add_blocks_to_trans(journal_transaction_t *trans,
*((__u32 *)buf) = 0;
jdbt->t_flags |= ext2fs_cpu_to_be16(JFS_FLAG_ESCAPE);
}
if (JFS_HAS_INCOMPAT_FEATURE(trans->journal,
JFS_FEATURE_INCOMPAT_64BIT))
if (jfs_has_feature_64bit(trans->journal))
jdbt->t_blocknr_high = ext2fs_cpu_to_be32(block_list[i] >> 32);
jbd2_block_tag_csum_set(trans->journal, jdbt, data_bh,
trans->tid);
@ -421,8 +417,7 @@ static blk64_t journal_guess_blocks(journal_t *journal, blk64_t data_blocks,
bs = journal->j_blocksize;
if (journal_has_csum_v2or3(journal))
bs -= sizeof(struct journal_revoke_tail);
sz = JFS_HAS_INCOMPAT_FEATURE(journal, JFS_FEATURE_INCOMPAT_64BIT) ?
sizeof(__u64) : sizeof(__u32);
sz = jfs_has_feature_64bit(journal) ? sizeof(__u64) : sizeof(__u32);
ret += revoke_blocks * sz / bs;
/* Estimate # of data blocks */
@ -489,10 +484,8 @@ static errcode_t journal_close_trans(journal_transaction_t *trans)
trans->magic = 0;
/* Mark ourselves as needing recovery */
if (!(EXT2_HAS_INCOMPAT_FEATURE(trans->fs->super,
EXT3_FEATURE_INCOMPAT_RECOVER))) {
trans->fs->super->s_feature_incompat |=
EXT3_FEATURE_INCOMPAT_RECOVER;
if (!ext2fs_has_feature_journal_needs_recovery(trans->fs->super)) {
ext2fs_set_feature_journal_needs_recovery(trans->fs->super);
ext2fs_mark_super_dirty(trans->fs);
}
@ -510,8 +503,7 @@ static errcode_t journal_write(journal_t *journal,
errcode_t err;
if (revoke_len > 0) {
journal->j_superblock->s_feature_incompat |=
ext2fs_cpu_to_be32(JFS_FEATURE_INCOMPAT_REVOKE);
jfs_set_feature_revoke(journal);
mark_buffer_dirty(journal->j_sb_buffer);
}
@ -774,33 +766,26 @@ static void update_journal_csum(journal_t *journal, int ver)
return;
if (journal->j_tail != 0 ||
EXT2_HAS_INCOMPAT_FEATURE(journal->j_fs_dev->k_fs->super,
EXT3_FEATURE_INCOMPAT_RECOVER)) {
ext2fs_has_feature_journal_needs_recovery(
journal->j_fs_dev->k_fs->super)) {
printf("Journal needs recovery, will not add csums.\n");
return;
}
/* metadata_csum implies journal csum v3 */
jsb = journal->j_superblock;
if (EXT2_HAS_RO_COMPAT_FEATURE(journal->j_fs_dev->k_fs->super,
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) {
if (ext2fs_has_feature_metadata_csum(journal->j_fs_dev->k_fs->super)) {
printf("Setting csum v%d\n", ver);
switch (ver) {
case 2:
journal->j_superblock->s_feature_incompat &=
ext2fs_cpu_to_be32(~JFS_FEATURE_INCOMPAT_CSUM_V3);
journal->j_superblock->s_feature_incompat |=
ext2fs_cpu_to_be32(JFS_FEATURE_INCOMPAT_CSUM_V2);
journal->j_superblock->s_feature_compat &=
ext2fs_cpu_to_be32(~JFS_FEATURE_COMPAT_CHECKSUM);
jfs_clear_feature_csum3(journal);
jfs_set_feature_csum2(journal);
jfs_clear_feature_checksum(journal);
break;
case 3:
journal->j_superblock->s_feature_incompat &=
ext2fs_cpu_to_be32(~JFS_FEATURE_INCOMPAT_CSUM_V2);
journal->j_superblock->s_feature_incompat |=
ext2fs_cpu_to_be32(JFS_FEATURE_INCOMPAT_CSUM_V3);
journal->j_superblock->s_feature_compat &=
ext2fs_cpu_to_be32(~JFS_FEATURE_COMPAT_CHECKSUM);
jfs_set_feature_csum3(journal);
jfs_clear_feature_csum2(journal);
jfs_clear_feature_checksum(journal);
break;
default:
printf("Unknown checksum v%d\n", ver);
@ -810,11 +795,9 @@ static void update_journal_csum(journal_t *journal, int ver)
journal->j_csum_seed = jbd2_chksum(journal, ~0, jsb->s_uuid,
sizeof(jsb->s_uuid));
} else {
journal->j_superblock->s_feature_compat |=
ext2fs_cpu_to_be32(JFS_FEATURE_COMPAT_CHECKSUM);
journal->j_superblock->s_feature_incompat &=
ext2fs_cpu_to_be32(~(JFS_FEATURE_INCOMPAT_CSUM_V2 |
JFS_FEATURE_INCOMPAT_CSUM_V3));
jfs_clear_feature_csum3(journal);
jfs_clear_feature_csum2(journal);
jfs_set_feature_checksum(journal);
}
}
@ -833,18 +816,15 @@ static void update_uuid(journal_t *journal)
return;
fs = journal->j_fs_dev->k_fs;
if (!EXT2_HAS_INCOMPAT_FEATURE(fs->super,
EXT4_FEATURE_INCOMPAT_64BIT))
if (!ext2fs_has_feature_64bit(fs->super))
return;
if (JFS_HAS_INCOMPAT_FEATURE(journal, JFS_FEATURE_INCOMPAT_64BIT) &&
EXT2_HAS_INCOMPAT_FEATURE(fs->super,
EXT4_FEATURE_INCOMPAT_64BIT))
if (jfs_has_feature_64bit(journal) &&
ext2fs_has_feature_64bit(fs->super))
return;
if (journal->j_tail != 0 ||
EXT2_HAS_INCOMPAT_FEATURE(fs->super,
EXT3_FEATURE_INCOMPAT_RECOVER)) {
ext2fs_has_feature_journal_needs_recovery(fs->super)) {
printf("Journal needs recovery, will not set 64bit.\n");
return;
}
@ -858,24 +838,21 @@ static void update_64bit_flag(journal_t *journal)
if (journal->j_format_version < 2)
return;
if (!EXT2_HAS_INCOMPAT_FEATURE(journal->j_fs_dev->k_fs->super,
EXT4_FEATURE_INCOMPAT_64BIT))
if (!ext2fs_has_feature_64bit(journal->j_fs_dev->k_fs->super))
return;
if (JFS_HAS_INCOMPAT_FEATURE(journal, JFS_FEATURE_INCOMPAT_64BIT) &&
EXT2_HAS_INCOMPAT_FEATURE(journal->j_fs_dev->k_fs->super,
EXT4_FEATURE_INCOMPAT_64BIT))
if (jfs_has_feature_64bit(journal) &&
ext2fs_has_feature_64bit(journal->j_fs_dev->k_fs->super))
return;
if (journal->j_tail != 0 ||
EXT2_HAS_INCOMPAT_FEATURE(journal->j_fs_dev->k_fs->super,
EXT3_FEATURE_INCOMPAT_RECOVER)) {
ext2fs_has_feature_journal_needs_recovery(
journal->j_fs_dev->k_fs->super)) {
printf("Journal needs recovery, will not set 64bit.\n");
return;
}
journal->j_superblock->s_feature_incompat |=
ext2fs_cpu_to_be32(JFS_FEATURE_INCOMPAT_64BIT);
jfs_set_feature_64bit(journal);
}
void do_journal_open(int argc, char *argv[])
@ -894,8 +871,7 @@ void do_journal_open(int argc, char *argv[])
printf("Journal is already open.\n");
return;
}
if (!EXT2_HAS_COMPAT_FEATURE(current_fs->super,
EXT3_FEATURE_COMPAT_HAS_JOURNAL)) {
if (!ext2fs_has_feature_journal(current_fs->super)) {
printf("Journalling is not enabled on this filesystem.\n");
return;
}
@ -978,8 +954,7 @@ void do_journal_run(int argc EXT2FS_ATTR((unused)), char *argv[])
if (err)
com_err("journal_run", err, "while recovering journal");
else {
current_fs->super->s_feature_incompat &=
~EXT3_FEATURE_INCOMPAT_RECOVER;
ext2fs_clear_feature_journal_needs_recovery(current_fs->super);
ext2fs_mark_super_dirty(current_fs);
}
}

3
debugfs/filefrag.c
View File

@ -145,8 +145,7 @@ static void filefrag(ext2_ino_t ino, struct ext2_inode *inode,
if (fs->options & VERBOSE_OPT) {
blk64_t num_blocks = ext2fs_inode_i_blocks(current_fs, inode);
if (!(current_fs->super->s_feature_ro_compat &
EXT4_FEATURE_RO_COMPAT_HUGE_FILE) ||
if (!ext2fs_has_feature_huge_file(current_fs->super) ||
!(inode->i_flags & EXT4_HUGE_FILE_FL))
num_blocks /= current_fs->blocksize / 512;

6
debugfs/htree.c
View File

@ -46,8 +46,7 @@ static void htree_dump_leaf_node(ext2_filsys fs, ext2_ino_t ino,
int hash_alg;
int csum_size = 0;
if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
if (ext2fs_has_feature_metadata_csum(fs->super))
csum_size = sizeof(struct ext2_dir_entry_tail);
errcode = ext2fs_bmap2(fs, ino, inode, buf, 0, blk, 0, &pblk);
@ -156,8 +155,7 @@ static void htree_dump_int_node(ext2_filsys fs, ext2_ino_t ino,
remainder -= sizeof(struct ext2_dx_root_info) + 24;
else
remainder -= 8;
if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) &&
if (ext2fs_has_feature_metadata_csum(fs->super) &&
remainder == sizeof(struct ext2_dx_tail)) {
tail = (struct ext2_dx_tail *)(ent + limit);
fprintf(pager, "Checksum: 0x%08x\n",

37
debugfs/journal.c
View File

@ -245,7 +245,7 @@ void wait_on_buffer(struct buffer_head *bh)
static void ext2fs_clear_recover(ext2_filsys fs, int error)
{
fs->super->s_feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER;
ext2fs_clear_feature_journal_needs_recovery(fs->super);
/* if we had an error doing journal recovery, we need a full fsck */
if (error)
@ -451,8 +451,7 @@ try_backup_journal:
ext2fs_swap_super(&jsuper);
#endif
if (jsuper.s_magic != EXT2_SUPER_MAGIC ||
!(jsuper.s_feature_incompat &
EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) {
!ext2fs_has_feature_journal_dev(&jsuper)) {
retval = EXT2_ET_LOAD_EXT_JOURNAL;
brelse(bh);
goto errout;
@ -466,8 +465,7 @@ try_backup_journal:
}
/* Check the superblock checksum */
if (jsuper.s_feature_ro_compat &
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) {
if (ext2fs_has_feature_metadata_csum(&jsuper)) {
struct struct_ext2_filsys fsx;
struct ext2_super_block superx;
void *p;
@ -476,8 +474,7 @@ try_backup_journal:
memcpy(&fsx, fs, sizeof(fsx));
memcpy(&superx, fs->super, sizeof(superx));
fsx.super = &superx;
fsx.super->s_feature_ro_compat |=
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM;
ext2fs_set_feature_metadata_csum(fsx.super);
if (!ext2fs_superblock_csum_verify(&fsx, p)) {
retval = EXT2_ET_LOAD_EXT_JOURNAL;
brelse(bh);
@ -522,10 +519,8 @@ errout:
static errcode_t ext2fs_journal_fix_bad_inode(ext2_filsys fs)
{
struct ext2_super_block *sb = fs->super;
int recover = fs->super->s_feature_incompat &
EXT3_FEATURE_INCOMPAT_RECOVER;
int has_journal = fs->super->s_feature_compat &
EXT3_FEATURE_COMPAT_HAS_JOURNAL;
int recover = ext2fs_has_feature_journal_needs_recovery(fs->super);
int has_journal = ext2fs_has_feature_journal(fs->super);
if (has_journal || sb->s_journal_inum) {
/* The journal inode is bogus, remove and force full fsck */
@ -604,12 +599,11 @@ static errcode_t ext2fs_journal_load(journal_t *journal)
return EXT2_ET_RO_UNSUPP_FEATURE;
/* Checksum v1-3 are mutually exclusive features. */
if (JFS_HAS_INCOMPAT_FEATURE(journal, JFS_FEATURE_INCOMPAT_CSUM_V2) &&
JFS_HAS_INCOMPAT_FEATURE(journal, JFS_FEATURE_INCOMPAT_CSUM_V3))
if (jfs_has_feature_csum2(journal) && jfs_has_feature_csum3(journal))
return EXT2_ET_CORRUPT_SUPERBLOCK;
if (journal_has_csum_v2or3(journal) &&
JFS_HAS_COMPAT_FEATURE(journal, JFS_FEATURE_COMPAT_CHECKSUM))
jfs_has_feature_checksum(journal))
return EXT2_ET_CORRUPT_SUPERBLOCK;
if (!ext2fs_journal_verify_csum_type(journal, jsb) ||
@ -680,12 +674,11 @@ static errcode_t ext2fs_check_ext3_journal(ext2_filsys fs)
{
struct ext2_super_block *sb = fs->super;
journal_t *journal;
int recover = fs->super->s_feature_incompat &
EXT3_FEATURE_INCOMPAT_RECOVER;
int recover = ext2fs_has_feature_journal_needs_recovery(fs->super);
errcode_t retval;
/* If we don't have any journal features, don't do anything more */
if (!(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) &&
if (!ext2fs_has_feature_journal(sb) &&
!recover && sb->s_journal_inum == 0 && sb->s_journal_dev == 0 &&
uuid_is_null(sb->s_journal_uuid))
return 0;
@ -703,13 +696,13 @@ static errcode_t ext2fs_check_ext3_journal(ext2_filsys fs)
* needs_recovery set but has_journal clear. We can't get in a loop
* with -y, -n, or -p, only if a user isn't making up their mind.
*/
if (!(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL)) {
if (!ext2fs_has_feature_journal(sb)) {
retval = EXT2_ET_JOURNAL_FLAGS_WRONG;
goto err;
}
if (sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL &&
!(sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) &&
if (ext2fs_has_feature_journal(sb) &&
!ext2fs_has_feature_journal_needs_recovery(sb) &&
journal->j_superblock->s_start != 0) {
retval = EXT2_ET_JOURNAL_FLAGS_WRONG;
goto err;
@ -720,7 +713,7 @@ static errcode_t ext2fs_check_ext3_journal(ext2_filsys fs)
* the journal's errno is set; if so, we need to mark the file
* system as being corrupt and clear the journal's s_errno.
*/
if (!(sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) &&
if (!ext2fs_has_feature_journal_needs_recovery(sb) &&
journal->j_superblock->s_errno) {
fs->super->s_state |= EXT2_ERROR_FS;
ext2fs_mark_super_dirty(fs);
@ -929,7 +922,7 @@ void jbd2_block_tag_csum_set(journal_t *j, journal_block_tag_t *tag,
csum32 = jbd2_chksum(j, j->j_csum_seed, (__u8 *)&seq, sizeof(seq));
csum32 = jbd2_chksum(j, csum32, bh->b_data, bh->b_size);
if (JFS_HAS_INCOMPAT_FEATURE(j, JFS_FEATURE_INCOMPAT_CSUM_V3))
if (jfs_has_feature_csum3(j))
tag3->t_checksum = ext2fs_cpu_to_be32(csum32);
else
tag->t_checksum = ext2fs_cpu_to_be16(csum32);

2
debugfs/logdump.c
View File

@ -364,7 +364,7 @@ static void dump_journal(char *cmdname, FILE *out_file,
if ((be32_to_cpu(jsb->s_header.h_magic) != JFS_MAGIC_NUMBER) &&
(sb->s_magic == EXT2_SUPER_MAGIC) &&
(sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) {
ext2fs_has_feature_journal_dev(sb)) {
blocksize = EXT2_BLOCK_SIZE(sb);
blocknr = (blocksize == 1024) ? 2 : 1;
uuid_unparse(sb->s_uuid, jsb_buffer);

3
debugfs/quota.c
View File

@ -34,8 +34,7 @@ static int load_quota_ctx(char *progname)
if (check_fs_open(progname))
return 1;
if (!EXT2_HAS_RO_COMPAT_FEATURE(current_fs->super,
EXT4_FEATURE_RO_COMPAT_QUOTA)) {
if (!ext2fs_has_feature_quota(current_fs->super)) {
com_err(progname, 0, "quota feature not enabled");
return 1;
}