#endif
#include "debugfs.h"
-#include "jfs_user.h"
#include "ext2fs/kernel-jbd.h"
-
-/* journal.c */
-errcode_t ext2fs_open_journal(ext2_filsys fs, journal_t **j);
-errcode_t ext2fs_close_journal(ext2_filsys fs, journal_t **j);
-errcode_t ext2fs_run_ext3_journal(ext2_filsys *fs);
-void jbd2_commit_block_csum_set(journal_t *j, struct buffer_head *bh);
-void jbd2_revoke_csum_set(journal_t *j, struct buffer_head *bh);
-void jbd2_descr_block_csum_set(journal_t *j, struct buffer_head *bh);
-void jbd2_block_tag_csum_set(journal_t *j, journal_block_tag_t *tag,
- struct buffer_head *bh, __u32 sequence);
+#include "journal.h"
#undef DEBUG
static journal_t *current_journal = NULL;
-static void journal_dump_trans(journal_transaction_t *trans, const char *tag)
+static void journal_dump_trans(journal_transaction_t *trans EXT2FS_ATTR((unused)),
+ const char *tag EXT2FS_ATTR((unused)))
{
dbg_printf("TRANS %p(%s): tid=%d start=%llu block=%llu end=%llu "
"flags=0x%x\n", trans, tag, trans->tid, trans->start,
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;
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)
void *buf;
size_t i, offset;
blk64_t curr_blk;
- int sz, csum_size = 0;
+ unsigned int sz;
+ unsigned csum_size = 0;
struct buffer_head *bh;
errcode_t err;
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;
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
*((__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);
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 */
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);
}
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);
}
return err;
}
-void do_journal_write(int argc, char *argv[])
+void do_journal_write(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)),
+ void *infop EXT2FS_ATTR((unused)))
{
blk64_t *blist = NULL, *rlist = NULL;
size_t bn = 0, rn = 0;
return nr;
}
-errcode_t journal_find_head(journal_t *journal)
+static errcode_t journal_find_head(journal_t *journal)
{
unsigned int next_commit_ID;
blk64_t next_log_block, head_block;
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);
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);
}
}
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;
}
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[])
+void do_journal_open(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)),
+ void *infop EXT2FS_ATTR((unused)))
{
int opt, enable_csum = 0, csum_ver = 3;
journal_t *journal;
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;
}
printf("%s: [-c] [-v ver] [-f ext_jnl]\n", argv[0]);
printf("-c: Enable journal checksumming.\n");
printf("-v: Use this version checksum format.\n");
- printf("-j: Load this external journal.\n");
+ printf("-f: Load this external journal.\n");
}
}
com_err(argv[0], err, "while examining journal");
}
-void do_journal_close(int argc, char *argv[])
+void do_journal_close(int argc EXT2FS_ATTR((unused)),
+ char *argv[] EXT2FS_ATTR((unused)),
+ int sci_idx EXT2FS_ATTR((unused)),
+ void *infop EXT2FS_ATTR((unused)))
{
if (current_journal == NULL) {
printf("Journal not open.\n");
ext2fs_close_journal(current_fs, ¤t_journal);
}
-void do_journal_run(int argc, char *argv[])
+void do_journal_run(int argc EXT2FS_ATTR((unused)), char *argv[],
+ int sci_idx EXT2FS_ATTR((unused)),
+ void *infop EXT2FS_ATTR((unused)))
{
errcode_t err;
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);
}
}