Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 818d276c authored by Girish Shilamkar's avatar Girish Shilamkar Committed by Theodore Ts'o
Browse files

ext4: Add the journal checksum feature 



The journal checksum feature adds two new flags i.e
JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT and JBD2_FEATURE_COMPAT_CHECKSUM.

JBD2_FEATURE_CHECKSUM flag indicates that the commit block contains the
checksum for the blocks described by the descriptor blocks.
Due to checksums, writing of the commit record no longer needs to be
synchronous. Now commit record can be sent to disk without waiting for
descriptor blocks to be written to disk. This behavior is controlled
using JBD2_FEATURE_ASYNC_COMMIT flag. Older kernels/e2fsck should not be
able to recover the journal with _ASYNC_COMMIT hence it is made
incompat.
The commit header has been extended to hold the checksum along with the
type of the checksum.

For recovery in pass scan checksums are verified to ensure the sanity
and completeness(in case of _ASYNC_COMMIT) of every transaction.

Signed-off-by: default avatarAndreas Dilger <adilger@clusterfs.com>
Signed-off-by: default avatarGirish Shilamkar <girish@clusterfs.com>
Signed-off-by: default avatarDave Kleikamp <shaggy@linux.vnet.ibm.com>
Signed-off-by: default avatarMingming Cao <cmm@us.ibm.com>
parent 8e85fb3f

Documentation/filesystems/ext4.txt

+10 −0
Original line number Diff line number Diff line
@@ -89,6 +89,16 @@ When mounting an ext4 filesystem, the following option are accepted: 
extents			ext4 will use extents to address file data.  The

			file system will no longer be mountable by ext3.



journal_checksum	Enable checksumming of the journal transactions.

			This will allow the recovery code in e2fsck and the

			kernel to detect corruption in the kernel.  It is a

			compatible change and will be ignored by older kernels.



journal_async_commit	Commit block can be written to disk without waiting

			for descriptor blocks. If enabled older kernels cannot

			mount the device. This will enable 'journal_checksum'

			internally.



journal=update		Update the ext4 file system's journal to the current

			format.

fs/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -236,6 +236,7 @@ config JBD_DEBUG 


config JBD2

	tristate

	select CRC32

	help

	  This is a generic journaling layer for block devices that support

	  both 32-bit and 64-bit block numbers.  It is currently used by

fs/ext4/super.c

+25 −0
Original line number Diff line number Diff line
@@ -869,6 +869,7 @@ enum { 
	Opt_user_xattr, Opt_nouser_xattr, Opt_acl, Opt_noacl,

	Opt_reservation, Opt_noreservation, Opt_noload, Opt_nobh, Opt_bh,

	Opt_commit, Opt_journal_update, Opt_journal_inum, Opt_journal_dev,

	Opt_journal_checksum, Opt_journal_async_commit,

	Opt_abort, Opt_data_journal, Opt_data_ordered, Opt_data_writeback,

	Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,

	Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_quota, Opt_noquota,
@@ -908,6 +909,8 @@ static match_table_t tokens = { 
	{Opt_journal_update, "journal=update"},

	{Opt_journal_inum, "journal=%u"},

	{Opt_journal_dev, "journal_dev=%u"},

	{Opt_journal_checksum, "journal_checksum"},

	{Opt_journal_async_commit, "journal_async_commit"},

	{Opt_abort, "abort"},

	{Opt_data_journal, "data=journal"},

	{Opt_data_ordered, "data=ordered"},
@@ -1095,6 +1098,13 @@ static int parse_options (char *options, struct super_block *sb, 
				return 0;

			*journal_devnum = option;

			break;

		case Opt_journal_checksum:

			set_opt(sbi->s_mount_opt, JOURNAL_CHECKSUM);

			break;

		case Opt_journal_async_commit:

			set_opt(sbi->s_mount_opt, JOURNAL_ASYNC_COMMIT);

			set_opt(sbi->s_mount_opt, JOURNAL_CHECKSUM);

			break;

		case Opt_noload:

			set_opt (sbi->s_mount_opt, NOLOAD);

			break;
@@ -2114,6 +2124,21 @@ static int ext4_fill_super (struct super_block *sb, void *data, int silent) 
		goto failed_mount4;

	}



	if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {

		jbd2_journal_set_features(sbi->s_journal,

				JBD2_FEATURE_COMPAT_CHECKSUM, 0,

				JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);

	} else if (test_opt(sb, JOURNAL_CHECKSUM)) {

		jbd2_journal_set_features(sbi->s_journal,

				JBD2_FEATURE_COMPAT_CHECKSUM, 0, 0);

		jbd2_journal_clear_features(sbi->s_journal, 0, 0,

				JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);

	} else {

		jbd2_journal_clear_features(sbi->s_journal,

				JBD2_FEATURE_COMPAT_CHECKSUM, 0,

				JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);

	}



	/* We have now updated the journal if required, so we can

	 * validate the data journaling mode. */

	switch (test_opt(sb, DATA_FLAGS)) {

fs/jbd2/commit.c

+149 −49
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ 
#include <linux/mm.h>

#include <linux/pagemap.h>

#include <linux/jiffies.h>

#include <linux/crc32.h>



/*

 * Default IO end handler for temporary BJ_IO buffer_heads.
@@ -93,19 +94,23 @@ static int inverted_lock(journal_t *journal, struct buffer_head *bh) 
	return 1;

}



/* Done it all: now write the commit record.  We should have

/*

 * Done it all: now submit the commit record.  We should have

 * cleaned up our previous buffers by now, so if we are in abort

 * mode we can now just skip the rest of the journal write

 * entirely.

 *

 * Returns 1 if the journal needs to be aborted or 0 on success

 */

static int journal_write_commit_record(journal_t *journal,

					transaction_t *commit_transaction)

static int journal_submit_commit_record(journal_t *journal,

					transaction_t *commit_transaction,

					struct buffer_head **cbh,

					__u32 crc32_sum)

{

	struct journal_head *descriptor;

	struct commit_header *tmp;

	struct buffer_head *bh;

	int i, ret;

	int ret;

	int barrier_done = 0;



	if (is_journal_aborted(journal))
@@ -117,21 +122,33 @@ static int journal_write_commit_record(journal_t *journal, 


	bh = jh2bh(descriptor);



	/* AKPM: buglet - add `i' to tmp! */

	for (i = 0; i < bh->b_size; i += 512) {

		journal_header_t *tmp = (journal_header_t*)bh->b_data;

	tmp = (struct commit_header *)bh->b_data;

	tmp->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER);

	tmp->h_blocktype = cpu_to_be32(JBD2_COMMIT_BLOCK);

	tmp->h_sequence = cpu_to_be32(commit_transaction->t_tid);



	if (JBD2_HAS_COMPAT_FEATURE(journal,

				    JBD2_FEATURE_COMPAT_CHECKSUM)) {

		tmp->h_chksum_type 	= JBD2_CRC32_CHKSUM;

		tmp->h_chksum_size 	= JBD2_CRC32_CHKSUM_SIZE;

		tmp->h_chksum[0] 	= cpu_to_be32(crc32_sum);

	}



	JBUFFER_TRACE(descriptor, "write commit block");

	JBUFFER_TRACE(descriptor, "submit commit block");

	lock_buffer(bh);



	set_buffer_dirty(bh);

	if (journal->j_flags & JBD2_BARRIER) {

	set_buffer_uptodate(bh);

	bh->b_end_io = journal_end_buffer_io_sync;



	if (journal->j_flags & JBD2_BARRIER &&

		!JBD2_HAS_COMPAT_FEATURE(journal,

					 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {

		set_buffer_ordered(bh);

		barrier_done = 1;

	}

	ret = sync_dirty_buffer(bh);

	ret = submit_bh(WRITE, bh);



	/* is it possible for another commit to fail at roughly

	 * the same time as this one?  If so, we don't want to

	 * trust the barrier flag in the super, but instead want
@@ -152,12 +169,70 @@ static int journal_write_commit_record(journal_t *journal, 
		clear_buffer_ordered(bh);

		set_buffer_uptodate(bh);

		set_buffer_dirty(bh);

		ret = sync_dirty_buffer(bh);

		ret = submit_bh(WRITE, bh);

	}

	*cbh = bh;

	return ret;

}



/*

 * This function along with journal_submit_commit_record

 * allows to write the commit record asynchronously.

 */

static int journal_wait_on_commit_record(struct buffer_head *bh)

{

	int ret = 0;



	clear_buffer_dirty(bh);

	wait_on_buffer(bh);



	if (unlikely(!buffer_uptodate(bh)))

		ret = -EIO;

	put_bh(bh);            /* One for getblk() */

	jbd2_journal_put_journal_head(descriptor);

	jbd2_journal_put_journal_head(bh2jh(bh));



	return (ret == -EIO);

	return ret;

}



/*

 * Wait for all submitted IO to complete.

 */

static int journal_wait_on_locked_list(journal_t *journal,

				       transaction_t *commit_transaction)

{

	int ret = 0;

	struct journal_head *jh;



	while (commit_transaction->t_locked_list) {

		struct buffer_head *bh;



		jh = commit_transaction->t_locked_list->b_tprev;

		bh = jh2bh(jh);

		get_bh(bh);

		if (buffer_locked(bh)) {

			spin_unlock(&journal->j_list_lock);

			wait_on_buffer(bh);

			if (unlikely(!buffer_uptodate(bh)))

				ret = -EIO;

			spin_lock(&journal->j_list_lock);

		}

		if (!inverted_lock(journal, bh)) {

			put_bh(bh);

			spin_lock(&journal->j_list_lock);

			continue;

		}

		if (buffer_jbd(bh) && jh->b_jlist == BJ_Locked) {

			__jbd2_journal_unfile_buffer(jh);

			jbd_unlock_bh_state(bh);

			jbd2_journal_remove_journal_head(bh);

			put_bh(bh);

		} else {

			jbd_unlock_bh_state(bh);

		}

		put_bh(bh);

		cond_resched_lock(&journal->j_list_lock);

	}

	return ret;

  }



static void journal_do_submit_data(struct buffer_head **wbuf, int bufs)
@@ -275,7 +350,21 @@ static void journal_submit_data_buffers(journal_t *journal, 
	journal_do_submit_data(wbuf, bufs);

}



static inline void write_tag_block(int tag_bytes, journal_block_tag_t *tag,

static __u32 jbd2_checksum_data(__u32 crc32_sum, struct buffer_head *bh)

{

	struct page *page = bh->b_page;

	char *addr;

	__u32 checksum;



	addr = kmap_atomic(page, KM_USER0);

	checksum = crc32_be(crc32_sum,

		(void *)(addr + offset_in_page(bh->b_data)), bh->b_size);

	kunmap_atomic(addr, KM_USER0);



	return checksum;

}



static void write_tag_block(int tag_bytes, journal_block_tag_t *tag,

				   unsigned long long block)

{

	tag->t_blocknr = cpu_to_be32(block & (u32)~0);
@@ -307,6 +396,8 @@ void jbd2_journal_commit_transaction(journal_t *journal) 
	int tag_flag;

	int i;

	int tag_bytes = journal_tag_bytes(journal);

	struct buffer_head *cbh = NULL; /* For transactional checksums */

	__u32 crc32_sum = ~0;



	/*

	 * First job: lock down the current transaction and wait for
@@ -451,38 +542,15 @@ void jbd2_journal_commit_transaction(journal_t *journal) 
	journal_submit_data_buffers(journal, commit_transaction);



	/*

	 * Wait for all previously submitted IO to complete.

	 * Wait for all previously submitted IO to complete if commit

	 * record is to be written synchronously.

	 */

	spin_lock(&journal->j_list_lock);

	while (commit_transaction->t_locked_list) {

		struct buffer_head *bh;

	if (!JBD2_HAS_INCOMPAT_FEATURE(journal,

		JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT))

		err = journal_wait_on_locked_list(journal,

						commit_transaction);



		jh = commit_transaction->t_locked_list->b_tprev;

		bh = jh2bh(jh);

		get_bh(bh);

		if (buffer_locked(bh)) {

			spin_unlock(&journal->j_list_lock);

			wait_on_buffer(bh);

			if (unlikely(!buffer_uptodate(bh)))

				err = -EIO;

			spin_lock(&journal->j_list_lock);

		}

		if (!inverted_lock(journal, bh)) {

			put_bh(bh);

			spin_lock(&journal->j_list_lock);

			continue;

		}

		if (buffer_jbd(bh) && jh->b_jlist == BJ_Locked) {

			__jbd2_journal_unfile_buffer(jh);

			jbd_unlock_bh_state(bh);

			jbd2_journal_remove_journal_head(bh);

			put_bh(bh);

		} else {

			jbd_unlock_bh_state(bh);

		}

		put_bh(bh);

		cond_resched_lock(&journal->j_list_lock);

	}

	spin_unlock(&journal->j_list_lock);



	if (err)
@@ -656,6 +724,15 @@ void jbd2_journal_commit_transaction(journal_t *journal) 
start_journal_io:

			for (i = 0; i < bufs; i++) {

				struct buffer_head *bh = wbuf[i];

				/*

				 * Compute checksum.

				 */

				if (JBD2_HAS_COMPAT_FEATURE(journal,

					JBD2_FEATURE_COMPAT_CHECKSUM)) {

					crc32_sum =

					    jbd2_checksum_data(crc32_sum, bh);

				}



				lock_buffer(bh);

				clear_buffer_dirty(bh);

				set_buffer_uptodate(bh);
@@ -672,6 +749,23 @@ void jbd2_journal_commit_transaction(journal_t *journal) 
		}

	}



	/* Done it all: now write the commit record asynchronously. */



	if (JBD2_HAS_INCOMPAT_FEATURE(journal,

		JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {

		err = journal_submit_commit_record(journal, commit_transaction,

						 &cbh, crc32_sum);

		if (err)

			__jbd2_journal_abort_hard(journal);



		spin_lock(&journal->j_list_lock);

		err = journal_wait_on_locked_list(journal,

						commit_transaction);

		spin_unlock(&journal->j_list_lock);

		if (err)

			__jbd2_journal_abort_hard(journal);

	}



	/* Lo and behold: we have just managed to send a transaction to

           the log.  Before we can commit it, wait for the IO so far to

           complete.  Control buffers being written are on the
@@ -771,8 +865,14 @@ void jbd2_journal_commit_transaction(journal_t *journal) 


	jbd_debug(3, "JBD: commit phase 6\n");



	if (journal_write_commit_record(journal, commit_transaction))

		err = -EIO;

	if (!JBD2_HAS_INCOMPAT_FEATURE(journal,

		JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {

		err = journal_submit_commit_record(journal, commit_transaction,

						&cbh, crc32_sum);

		if (err)

			__jbd2_journal_abort_hard(journal);

	}

	err = journal_wait_on_commit_record(cbh);



	if (err)

		jbd2_journal_abort(journal, err);

fs/jbd2/journal.c

+26 −0
Original line number Diff line number Diff line
@@ -1578,6 +1578,32 @@ int jbd2_journal_set_features (journal_t *journal, unsigned long compat, 
	return 1;

}



/*

 * jbd2_journal_clear_features () - Clear a given journal feature in the

 * 				    superblock

 * @journal: Journal to act on.

 * @compat: bitmask of compatible features

 * @ro: bitmask of features that force read-only mount

 * @incompat: bitmask of incompatible features

 *

 * Clear a given journal feature as present on the

 * superblock.

 */

void jbd2_journal_clear_features(journal_t *journal, unsigned long compat,

				unsigned long ro, unsigned long incompat)

{

	journal_superblock_t *sb;



	jbd_debug(1, "Clear features 0x%lx/0x%lx/0x%lx\n",

		  compat, ro, incompat);



	sb = journal->j_superblock;



	sb->s_feature_compat    &= ~cpu_to_be32(compat);

	sb->s_feature_ro_compat &= ~cpu_to_be32(ro);

	sb->s_feature_incompat  &= ~cpu_to_be32(incompat);

}

EXPORT_SYMBOL(jbd2_journal_clear_features);



/**

 * int jbd2_journal_update_format () - Update on-disk journal structure.