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

Commit f7f4bccb authored by Mingming Cao's avatar Mingming Cao Committed by Linus Torvalds
Browse files

[PATCH] jbd2: rename jbd2 symbols to avoid duplication of jbd symbols 



Mingming Cao originally did this work, and Shaggy reproduced it using some
scripts from her.

Signed-off-by: default avatarMingming Cao <cmm@us.ibm.com>
Signed-off-by: default avatarDave Kleikamp <shaggy@austin.ibm.com>
Signed-off-by: default avatarAndrew Morton <akpm@osdl.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent 470decc6

fs/jbd2/Makefile

+2 −2
Original line number Diff line number Diff line
@@ -2,6 +2,6 @@ 
# Makefile for the linux journaling routines.

#



obj-$(CONFIG_JBD) += jbd.o

obj-$(CONFIG_JBD2) += jbd2.o



jbd-objs := transaction.o commit.o recovery.o checkpoint.o revoke.o journal.o
 
jbd2-objs := transaction.o commit.o recovery.o checkpoint.o revoke.o journal.o

fs/jbd2/checkpoint.c

+27 −27
Original line number Diff line number Diff line
@@ -19,7 +19,7 @@ 


#include <linux/time.h>

#include <linux/fs.h>

#include <linux/jbd.h>

#include <linux/jbd2.h>

#include <linux/errno.h>

#include <linux/slab.h>
@@ -95,9 +95,9 @@ static int __try_to_free_cp_buf(struct journal_head *jh) 


	if (jh->b_jlist == BJ_None && !buffer_locked(bh) && !buffer_dirty(bh)) {

		JBUFFER_TRACE(jh, "remove from checkpoint list");

		ret = __journal_remove_checkpoint(jh) + 1;

		ret = __jbd2_journal_remove_checkpoint(jh) + 1;

		jbd_unlock_bh_state(bh);

		journal_remove_journal_head(bh);

		jbd2_journal_remove_journal_head(bh);

		BUFFER_TRACE(bh, "release");

		__brelse(bh);

	} else {
@@ -107,19 +107,19 @@ static int __try_to_free_cp_buf(struct journal_head *jh) 
}



/*

 * __log_wait_for_space: wait until there is space in the journal.

 * __jbd2_log_wait_for_space: wait until there is space in the journal.

 *

 * Called under j-state_lock *only*.  It will be unlocked if we have to wait

 * for a checkpoint to free up some space in the log.

 */

void __log_wait_for_space(journal_t *journal)

void __jbd2_log_wait_for_space(journal_t *journal)

{

	int nblocks;

	assert_spin_locked(&journal->j_state_lock);



	nblocks = jbd_space_needed(journal);

	while (__log_space_left(journal) < nblocks) {

		if (journal->j_flags & JFS_ABORT)

	while (__jbd2_log_space_left(journal) < nblocks) {

		if (journal->j_flags & JBD2_ABORT)

			return;

		spin_unlock(&journal->j_state_lock);

		mutex_lock(&journal->j_checkpoint_mutex);
@@ -130,9 +130,9 @@ void __log_wait_for_space(journal_t *journal) 
		 */

		spin_lock(&journal->j_state_lock);

		nblocks = jbd_space_needed(journal);

		if (__log_space_left(journal) < nblocks) {

		if (__jbd2_log_space_left(journal) < nblocks) {

			spin_unlock(&journal->j_state_lock);

			log_do_checkpoint(journal);

			jbd2_log_do_checkpoint(journal);

			spin_lock(&journal->j_state_lock);

		}

		mutex_unlock(&journal->j_checkpoint_mutex);
@@ -198,9 +198,9 @@ static void __wait_cp_io(journal_t *journal, transaction_t *transaction) 
		 * Now in whatever state the buffer currently is, we know that

		 * it has been written out and so we can drop it from the list

		 */

		released = __journal_remove_checkpoint(jh);

		released = __jbd2_journal_remove_checkpoint(jh);

		jbd_unlock_bh_state(bh);

		journal_remove_journal_head(bh);

		jbd2_journal_remove_journal_head(bh);

		__brelse(bh);

	}

}
@@ -252,16 +252,16 @@ static int __process_buffer(journal_t *journal, struct journal_head *jh, 


		spin_unlock(&journal->j_list_lock);

		jbd_unlock_bh_state(bh);

		log_start_commit(journal, tid);

		log_wait_commit(journal, tid);

		jbd2_log_start_commit(journal, tid);

		jbd2_log_wait_commit(journal, tid);

		ret = 1;

	} else if (!buffer_dirty(bh)) {

		J_ASSERT_JH(jh, !buffer_jbddirty(bh));

		BUFFER_TRACE(bh, "remove from checkpoint");

		__journal_remove_checkpoint(jh);

		__jbd2_journal_remove_checkpoint(jh);

		spin_unlock(&journal->j_list_lock);

		jbd_unlock_bh_state(bh);

		journal_remove_journal_head(bh);

		jbd2_journal_remove_journal_head(bh);

		__brelse(bh);

		ret = 1;

	} else {
@@ -296,7 +296,7 @@ static int __process_buffer(journal_t *journal, struct journal_head *jh, 
 *

 * The journal should be locked before calling this function.

 */

int log_do_checkpoint(journal_t *journal)

int jbd2_log_do_checkpoint(journal_t *journal)

{

	transaction_t *transaction;

	tid_t this_tid;
@@ -309,7 +309,7 @@ int log_do_checkpoint(journal_t *journal) 
	 * don't need checkpointing, just eliminate them from the

	 * journal straight away.

	 */

	result = cleanup_journal_tail(journal);

	result = jbd2_cleanup_journal_tail(journal);

	jbd_debug(1, "cleanup_journal_tail returned %d\n", result);

	if (result <= 0)

		return result;
@@ -374,7 +374,7 @@ int log_do_checkpoint(journal_t *journal) 
	}

out:

	spin_unlock(&journal->j_list_lock);

	result = cleanup_journal_tail(journal);

	result = jbd2_cleanup_journal_tail(journal);

	if (result < 0)

		return result;

	return 0;
@@ -397,7 +397,7 @@ int log_do_checkpoint(journal_t *journal) 
 * we have an abort error outstanding.

 */



int cleanup_journal_tail(journal_t *journal)

int jbd2_cleanup_journal_tail(journal_t *journal)

{

	transaction_t * transaction;

	tid_t		first_tid;
@@ -452,8 +452,8 @@ int cleanup_journal_tail(journal_t *journal) 
	journal->j_tail_sequence = first_tid;

	journal->j_tail = blocknr;

	spin_unlock(&journal->j_state_lock);

	if (!(journal->j_flags & JFS_ABORT))

		journal_update_superblock(journal, 1);

	if (!(journal->j_flags & JBD2_ABORT))

		jbd2_journal_update_superblock(journal, 1);

	return 0;

}
@@ -518,7 +518,7 @@ static int journal_clean_one_cp_list(struct journal_head *jh, int *released) 
 * Returns number of buffers reaped (for debug)

 */



int __journal_clean_checkpoint_list(journal_t *journal)

int __jbd2_journal_clean_checkpoint_list(journal_t *journal)

{

	transaction_t *transaction, *last_transaction, *next_transaction;

	int ret = 0;
@@ -578,7 +578,7 @@ int __journal_clean_checkpoint_list(journal_t *journal) 
 * This function is called with jbd_lock_bh_state(jh2bh(jh))

 */



int __journal_remove_checkpoint(struct journal_head *jh)

int __jbd2_journal_remove_checkpoint(struct journal_head *jh)

{

	transaction_t *transaction;

	journal_t *journal;
@@ -607,7 +607,7 @@ int __journal_remove_checkpoint(struct journal_head *jh) 
	 * dropped!

	 *

	 * The locking here around j_committing_transaction is a bit sleazy.

	 * See the comment at the end of journal_commit_transaction().

	 * See the comment at the end of jbd2_journal_commit_transaction().

	 */

	if (transaction == journal->j_committing_transaction) {

		JBUFFER_TRACE(jh, "belongs to committing transaction");
@@ -617,7 +617,7 @@ int __journal_remove_checkpoint(struct journal_head *jh) 
	/* OK, that was the last buffer for the transaction: we can now

	   safely remove this transaction from the log */



	__journal_drop_transaction(journal, transaction);

	__jbd2_journal_drop_transaction(journal, transaction);



	/* Just in case anybody was waiting for more transactions to be

           checkpointed... */
@@ -636,7 +636,7 @@ int __journal_remove_checkpoint(struct journal_head *jh) 
 * Called with the journal locked.

 * Called with j_list_lock held.

 */

void __journal_insert_checkpoint(struct journal_head *jh,

void __jbd2_journal_insert_checkpoint(struct journal_head *jh,

			       transaction_t *transaction)

{

	JBUFFER_TRACE(jh, "entry");
@@ -666,7 +666,7 @@ void __journal_insert_checkpoint(struct journal_head *jh, 
 * Called with j_list_lock held.

 */



void __journal_drop_transaction(journal_t *journal, transaction_t *transaction)

void __jbd2_journal_drop_transaction(journal_t *journal, transaction_t *transaction)

{

	assert_spin_locked(&journal->j_list_lock);

	if (transaction->t_cpnext) {

fs/jbd2/commit.c

+61 −61
Original line number Diff line number Diff line 
/*

 * linux/fs/jbd/commit.c

 * linux/fs/jbd2/commit.c

 *

 * Written by Stephen C. Tweedie <sct@redhat.com>, 1998

 *
@@ -15,7 +15,7 @@ 


#include <linux/time.h>

#include <linux/fs.h>

#include <linux/jbd.h>

#include <linux/jbd2.h>

#include <linux/errno.h>

#include <linux/slab.h>

#include <linux/mm.h>
@@ -111,7 +111,7 @@ static int journal_write_commit_record(journal_t *journal, 
	if (is_journal_aborted(journal))

		return 0;



	descriptor = journal_get_descriptor_buffer(journal);

	descriptor = jbd2_journal_get_descriptor_buffer(journal);

	if (!descriptor)

		return 1;
@@ -120,14 +120,14 @@ static int journal_write_commit_record(journal_t *journal, 
	/* 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->h_magic = cpu_to_be32(JFS_MAGIC_NUMBER);

		tmp->h_blocktype = cpu_to_be32(JFS_COMMIT_BLOCK);

		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);

	}



	JBUFFER_TRACE(descriptor, "write commit block");

	set_buffer_dirty(bh);

	if (journal->j_flags & JFS_BARRIER) {

	if (journal->j_flags & JBD2_BARRIER) {

		set_buffer_ordered(bh);

		barrier_done = 1;

	}
@@ -145,7 +145,7 @@ static int journal_write_commit_record(journal_t *journal, 
			"disabling barriers\n",

			bdevname(journal->j_dev, b));

		spin_lock(&journal->j_state_lock);

		journal->j_flags &= ~JFS_BARRIER;

		journal->j_flags &= ~JBD2_BARRIER;

		spin_unlock(&journal->j_state_lock);



		/* And try again, without the barrier */
@@ -155,7 +155,7 @@ static int journal_write_commit_record(journal_t *journal, 
		ret = sync_dirty_buffer(bh);

	}

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

	journal_put_journal_head(descriptor);

	jbd2_journal_put_journal_head(descriptor);



	return (ret == -EIO);

}
@@ -239,7 +239,7 @@ static void journal_submit_data_buffers(journal_t *journal, 
		if (locked && test_clear_buffer_dirty(bh)) {

			BUFFER_TRACE(bh, "needs writeout, adding to array");

			wbuf[bufs++] = bh;

			__journal_file_buffer(jh, commit_transaction,

			__jbd2_journal_file_buffer(jh, commit_transaction,

						BJ_Locked);

			jbd_unlock_bh_state(bh);

			if (bufs == journal->j_wbufsize) {
@@ -251,13 +251,13 @@ static void journal_submit_data_buffers(journal_t *journal, 
		}

		else {

			BUFFER_TRACE(bh, "writeout complete: unfile");

			__journal_unfile_buffer(jh);

			__jbd2_journal_unfile_buffer(jh);

			jbd_unlock_bh_state(bh);

			if (locked)

				unlock_buffer(bh);

			journal_remove_journal_head(bh);

			jbd2_journal_remove_journal_head(bh);

			/* Once for our safety reference, once for

			 * journal_remove_journal_head() */

			 * jbd2_journal_remove_journal_head() */

			put_bh(bh);

			put_bh(bh);

		}
@@ -272,12 +272,12 @@ static void journal_submit_data_buffers(journal_t *journal, 
}



/*

 * journal_commit_transaction

 * jbd2_journal_commit_transaction

 *

 * The primary function for committing a transaction to the log.  This

 * function is called by the journal thread to begin a complete commit.

 */

void journal_commit_transaction(journal_t *journal)

void jbd2_journal_commit_transaction(journal_t *journal)

{

	transaction_t *commit_transaction;

	struct journal_head *jh, *new_jh, *descriptor;
@@ -305,10 +305,10 @@ void journal_commit_transaction(journal_t *journal) 
	spin_unlock(&journal->j_list_lock);

#endif



	/* Do we need to erase the effects of a prior journal_flush? */

	if (journal->j_flags & JFS_FLUSHED) {

	/* Do we need to erase the effects of a prior jbd2_journal_flush? */

	if (journal->j_flags & JBD2_FLUSHED) {

		jbd_debug(3, "super block updated\n");

		journal_update_superblock(journal, 1);

		jbd2_journal_update_superblock(journal, 1);

	} else {

		jbd_debug(3, "superblock not updated\n");

	}
@@ -350,7 +350,7 @@ void journal_commit_transaction(journal_t *journal) 
	 * BJ_Reserved buffers.  Note, it is _not_ permissible to assume

	 * that there are no such buffers: if a large filesystem

	 * operation like a truncate needs to split itself over multiple

	 * transactions, then it may try to do a journal_restart() while

	 * transactions, then it may try to do a jbd2_journal_restart() while

	 * there are still BJ_Reserved buffers outstanding.  These must

	 * be released cleanly from the current transaction.

	 *
@@ -358,25 +358,25 @@ void journal_commit_transaction(journal_t *journal) 
	 * again before modifying the buffer in the new transaction, but

	 * we do not require it to remember exactly which old buffers it

	 * has reserved.  This is consistent with the existing behaviour

	 * that multiple journal_get_write_access() calls to the same

	 * that multiple jbd2_journal_get_write_access() calls to the same

	 * buffer are perfectly permissable.

	 */

	while (commit_transaction->t_reserved_list) {

		jh = commit_transaction->t_reserved_list;

		JBUFFER_TRACE(jh, "reserved, unused: refile");

		/*

		 * A journal_get_undo_access()+journal_release_buffer() may

		 * A jbd2_journal_get_undo_access()+jbd2_journal_release_buffer() may

		 * leave undo-committed data.

		 */

		if (jh->b_committed_data) {

			struct buffer_head *bh = jh2bh(jh);



			jbd_lock_bh_state(bh);

			jbd_slab_free(jh->b_committed_data, bh->b_size);

			jbd2_slab_free(jh->b_committed_data, bh->b_size);

			jh->b_committed_data = NULL;

			jbd_unlock_bh_state(bh);

		}

		journal_refile_buffer(journal, jh);

		jbd2_journal_refile_buffer(journal, jh);

	}



	/*
@@ -385,7 +385,7 @@ void journal_commit_transaction(journal_t *journal) 
	 * frees some memory

	 */

	spin_lock(&journal->j_list_lock);

	__journal_clean_checkpoint_list(journal);

	__jbd2_journal_clean_checkpoint_list(journal);

	spin_unlock(&journal->j_list_lock);



	jbd_debug (3, "JBD: commit phase 1\n");
@@ -393,7 +393,7 @@ void journal_commit_transaction(journal_t *journal) 
	/*

	 * Switch to a new revoke table.

	 */

	journal_switch_revoke_table(journal);

	jbd2_journal_switch_revoke_table(journal);



	commit_transaction->t_state = T_FLUSH;

	journal->j_committing_transaction = commit_transaction;
@@ -450,9 +450,9 @@ void journal_commit_transaction(journal_t *journal) 
			continue;

		}

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

			__journal_unfile_buffer(jh);

			__jbd2_journal_unfile_buffer(jh);

			jbd_unlock_bh_state(bh);

			journal_remove_journal_head(bh);

			jbd2_journal_remove_journal_head(bh);

			put_bh(bh);

		} else {

			jbd_unlock_bh_state(bh);
@@ -463,9 +463,9 @@ void journal_commit_transaction(journal_t *journal) 
	spin_unlock(&journal->j_list_lock);



	if (err)

		__journal_abort_hard(journal);

		__jbd2_journal_abort_hard(journal);



	journal_write_revoke_records(journal, commit_transaction);

	jbd2_journal_write_revoke_records(journal, commit_transaction);



	jbd_debug(3, "JBD: commit phase 2\n");
@@ -499,7 +499,7 @@ void journal_commit_transaction(journal_t *journal) 


		if (is_journal_aborted(journal)) {

			JBUFFER_TRACE(jh, "journal is aborting: refile");

			journal_refile_buffer(journal, jh);

			jbd2_journal_refile_buffer(journal, jh);

			/* If that was the last one, we need to clean up

			 * any descriptor buffers which may have been

			 * already allocated, even if we are now
@@ -519,9 +519,9 @@ void journal_commit_transaction(journal_t *journal) 


			jbd_debug(4, "JBD: get descriptor\n");



			descriptor = journal_get_descriptor_buffer(journal);

			descriptor = jbd2_journal_get_descriptor_buffer(journal);

			if (!descriptor) {

				__journal_abort_hard(journal);

				__jbd2_journal_abort_hard(journal);

				continue;

			}
@@ -529,8 +529,8 @@ void journal_commit_transaction(journal_t *journal) 
			jbd_debug(4, "JBD: got buffer %llu (%p)\n",

				(unsigned long long)bh->b_blocknr, bh->b_data);

			header = (journal_header_t *)&bh->b_data[0];

			header->h_magic     = cpu_to_be32(JFS_MAGIC_NUMBER);

			header->h_blocktype = cpu_to_be32(JFS_DESCRIPTOR_BLOCK);

			header->h_magic     = cpu_to_be32(JBD2_MAGIC_NUMBER);

			header->h_blocktype = cpu_to_be32(JBD2_DESCRIPTOR_BLOCK);

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



			tagp = &bh->b_data[sizeof(journal_header_t)];
@@ -543,25 +543,25 @@ void journal_commit_transaction(journal_t *journal) 
			/* Record it so that we can wait for IO

                           completion later */

			BUFFER_TRACE(bh, "ph3: file as descriptor");

			journal_file_buffer(descriptor, commit_transaction,

			jbd2_journal_file_buffer(descriptor, commit_transaction,

					BJ_LogCtl);

		}



		/* Where is the buffer to be written? */



		err = journal_next_log_block(journal, &blocknr);

		err = jbd2_journal_next_log_block(journal, &blocknr);

		/* If the block mapping failed, just abandon the buffer

		   and repeat this loop: we'll fall into the

		   refile-on-abort condition above. */

		if (err) {

			__journal_abort_hard(journal);

			__jbd2_journal_abort_hard(journal);

			continue;

		}



		/*

		 * start_this_handle() uses t_outstanding_credits to determine

		 * the free space in the log, but this counter is changed

		 * by journal_next_log_block() also.

		 * by jbd2_journal_next_log_block() also.

		 */

		commit_transaction->t_outstanding_credits--;
@@ -576,13 +576,13 @@ void journal_commit_transaction(journal_t *journal) 


		set_bit(BH_JWrite, &jh2bh(jh)->b_state);

		/*

		 * akpm: journal_write_metadata_buffer() sets

		 * akpm: jbd2_journal_write_metadata_buffer() sets

		 * new_bh->b_transaction to commit_transaction.

		 * We need to clean this up before we release new_bh

		 * (which is of type BJ_IO)

		 */

		JBUFFER_TRACE(jh, "ph3: write metadata");

		flags = journal_write_metadata_buffer(commit_transaction,

		flags = jbd2_journal_write_metadata_buffer(commit_transaction,

						      jh, &new_jh, blocknr);

		set_bit(BH_JWrite, &jh2bh(new_jh)->b_state);

		wbuf[bufs++] = jh2bh(new_jh);
@@ -592,9 +592,9 @@ void journal_commit_transaction(journal_t *journal) 


		tag_flag = 0;

		if (flags & 1)

			tag_flag |= JFS_FLAG_ESCAPE;

			tag_flag |= JBD2_FLAG_ESCAPE;

		if (!first_tag)

			tag_flag |= JFS_FLAG_SAME_UUID;

			tag_flag |= JBD2_FLAG_SAME_UUID;



		tag = (journal_block_tag_t *) tagp;

		tag->t_blocknr = cpu_to_be32(jh2bh(jh)->b_blocknr);
@@ -622,7 +622,7 @@ void journal_commit_transaction(journal_t *journal) 
                           submitting the IOs.  "tag" still points to

                           the last tag we set up. */



			tag->t_flags |= cpu_to_be32(JFS_FLAG_LAST_TAG);

			tag->t_flags |= cpu_to_be32(JBD2_FLAG_LAST_TAG);



start_journal_io:

			for (i = 0; i < bufs; i++) {
@@ -678,14 +678,14 @@ void journal_commit_transaction(journal_t *journal) 
		clear_buffer_jwrite(bh);



		JBUFFER_TRACE(jh, "ph4: unfile after journal write");

		journal_unfile_buffer(journal, jh);

		jbd2_journal_unfile_buffer(journal, jh);



		/*

		 * ->t_iobuf_list should contain only dummy buffer_heads

		 * which were created by journal_write_metadata_buffer().

		 * which were created by jbd2_journal_write_metadata_buffer().

		 */

		BUFFER_TRACE(bh, "dumping temporary bh");

		journal_put_journal_head(jh);

		jbd2_journal_put_journal_head(jh);

		__brelse(bh);

		J_ASSERT_BH(bh, atomic_read(&bh->b_count) == 0);

		free_buffer_head(bh);
@@ -702,7 +702,7 @@ void journal_commit_transaction(journal_t *journal) 
                   we finally commit, we can do any checkpointing

                   required. */

		JBUFFER_TRACE(jh, "file as BJ_Forget");

		journal_file_buffer(jh, commit_transaction, BJ_Forget);

		jbd2_journal_file_buffer(jh, commit_transaction, BJ_Forget);

		/* Wake up any transactions which were waiting for this

		   IO to complete */

		wake_up_bit(&bh->b_state, BH_Unshadow);
@@ -733,8 +733,8 @@ void journal_commit_transaction(journal_t *journal) 


		BUFFER_TRACE(bh, "ph5: control buffer writeout done: unfile");

		clear_buffer_jwrite(bh);

		journal_unfile_buffer(journal, jh);

		journal_put_journal_head(jh);

		jbd2_journal_unfile_buffer(journal, jh);

		jbd2_journal_put_journal_head(jh);

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

		/* AKPM: bforget here */

	}
@@ -745,7 +745,7 @@ void journal_commit_transaction(journal_t *journal) 
		err = -EIO;



	if (err)

		__journal_abort_hard(journal);

		__jbd2_journal_abort_hard(journal);



	/* End of a transaction!  Finally, we can do checkpoint

           processing: any buffers committed as a result of this
@@ -789,14 +789,14 @@ void journal_commit_transaction(journal_t *journal) 
		 * Otherwise, we can just throw away the frozen data now.

		 */

		if (jh->b_committed_data) {

			jbd_slab_free(jh->b_committed_data, bh->b_size);

			jbd2_slab_free(jh->b_committed_data, bh->b_size);

			jh->b_committed_data = NULL;

			if (jh->b_frozen_data) {

				jh->b_committed_data = jh->b_frozen_data;

				jh->b_frozen_data = NULL;

			}

		} else if (jh->b_frozen_data) {

			jbd_slab_free(jh->b_frozen_data, bh->b_size);

			jbd2_slab_free(jh->b_frozen_data, bh->b_size);

			jh->b_frozen_data = NULL;

		}
@@ -804,12 +804,12 @@ void journal_commit_transaction(journal_t *journal) 
		cp_transaction = jh->b_cp_transaction;

		if (cp_transaction) {

			JBUFFER_TRACE(jh, "remove from old cp transaction");

			__journal_remove_checkpoint(jh);

			__jbd2_journal_remove_checkpoint(jh);

		}



		/* Only re-checkpoint the buffer_head if it is marked

		 * dirty.  If the buffer was added to the BJ_Forget list

		 * by journal_forget, it may no longer be dirty and

		 * by jbd2_journal_forget, it may no longer be dirty and

		 * there's no point in keeping a checkpoint record for

		 * it. */
@@ -828,9 +828,9 @@ void journal_commit_transaction(journal_t *journal) 


		if (buffer_jbddirty(bh)) {

			JBUFFER_TRACE(jh, "add to new checkpointing trans");

			__journal_insert_checkpoint(jh, commit_transaction);

			__jbd2_journal_insert_checkpoint(jh, commit_transaction);

			JBUFFER_TRACE(jh, "refile for checkpoint writeback");

			__journal_refile_buffer(jh);

			__jbd2_journal_refile_buffer(jh);

			jbd_unlock_bh_state(bh);

		} else {

			J_ASSERT_BH(bh, !buffer_dirty(bh));
@@ -842,11 +842,11 @@ void journal_commit_transaction(journal_t *journal) 
			 * disk and before we process the buffer on BJ_Forget

			 * list. */

			JBUFFER_TRACE(jh, "refile or unfile freed buffer");

			__journal_refile_buffer(jh);

			__jbd2_journal_refile_buffer(jh);

			if (!jh->b_transaction) {

				jbd_unlock_bh_state(bh);

				 /* needs a brelse */

				journal_remove_journal_head(bh);

				jbd2_journal_remove_journal_head(bh);

				release_buffer_page(bh);

			} else

				jbd_unlock_bh_state(bh);
@@ -856,9 +856,9 @@ void journal_commit_transaction(journal_t *journal) 
	spin_unlock(&journal->j_list_lock);

	/*

	 * This is a bit sleazy.  We borrow j_list_lock to protect

	 * journal->j_committing_transaction in __journal_remove_checkpoint.

	 * Really, __journal_remove_checkpoint should be using j_state_lock but

	 * it's a bit hassle to hold that across __journal_remove_checkpoint

	 * journal->j_committing_transaction in __jbd2_journal_remove_checkpoint.

	 * Really, __jbd2_journal_remove_checkpoint should be using j_state_lock but

	 * it's a bit hassle to hold that across __jbd2_journal_remove_checkpoint

	 */

	spin_lock(&journal->j_state_lock);

	spin_lock(&journal->j_list_lock);
@@ -885,7 +885,7 @@ void journal_commit_transaction(journal_t *journal) 
	spin_unlock(&journal->j_state_lock);



	if (commit_transaction->t_checkpoint_list == NULL) {

		__journal_drop_transaction(journal, commit_transaction);

		__jbd2_journal_drop_transaction(journal, commit_transaction);

	} else {

		if (journal->j_checkpoint_transactions == NULL) {

			journal->j_checkpoint_transactions = commit_transaction;

fs/jbd2/journal.c

+227 −227

File changed.

Preview size limit exceeded, changes collapsed.

fs/jbd2/recovery.c

+23 −23
Original line number Diff line number Diff line
@@ -18,7 +18,7 @@ 
#else

#include <linux/time.h>

#include <linux/fs.h>

#include <linux/jbd.h>

#include <linux/jbd2.h>

#include <linux/errno.h>

#include <linux/slab.h>

#endif
@@ -86,7 +86,7 @@ static int do_readahead(journal_t *journal, unsigned int start) 
	nbufs = 0;



	for (next = start; next < max; next++) {

		err = journal_bmap(journal, next, &blocknr);

		err = jbd2_journal_bmap(journal, next, &blocknr);



		if (err) {

			printk (KERN_ERR "JBD: bad block at offset %u\n",
@@ -142,7 +142,7 @@ static int jread(struct buffer_head **bhp, journal_t *journal, 
		return -EIO;

	}



	err = journal_bmap(journal, offset, &blocknr);

	err = jbd2_journal_bmap(journal, offset, &blocknr);



	if (err) {

		printk (KERN_ERR "JBD: bad block at offset %u\n",
@@ -191,10 +191,10 @@ static int count_tags(struct buffer_head *bh, int size) 


		nr++;

		tagp += sizeof(journal_block_tag_t);

		if (!(tag->t_flags & cpu_to_be32(JFS_FLAG_SAME_UUID)))

		if (!(tag->t_flags & cpu_to_be32(JBD2_FLAG_SAME_UUID)))

			tagp += 16;



		if (tag->t_flags & cpu_to_be32(JFS_FLAG_LAST_TAG))

		if (tag->t_flags & cpu_to_be32(JBD2_FLAG_LAST_TAG))

			break;

	}
@@ -210,7 +210,7 @@ do { \ 
} while (0)



/**

 * journal_recover - recovers a on-disk journal

 * jbd2_journal_recover - recovers a on-disk journal

 * @journal: the journal to recover

 *

 * The primary function for recovering the log contents when mounting a
@@ -221,7 +221,7 @@ do { \ 
 * blocks.  In the third and final pass, we replay any un-revoked blocks

 * in the log.

 */

int journal_recover(journal_t *journal)

int jbd2_journal_recover(journal_t *journal)

{

	int			err;

	journal_superblock_t *	sb;
@@ -260,13 +260,13 @@ int journal_recover(journal_t *journal) 
	 * any existing commit records in the log. */

	journal->j_transaction_sequence = ++info.end_transaction;



	journal_clear_revoke(journal);

	jbd2_journal_clear_revoke(journal);

	sync_blockdev(journal->j_fs_dev);

	return err;

}



/**

 * journal_skip_recovery - Start journal and wipe exiting records

 * jbd2_journal_skip_recovery - Start journal and wipe exiting records

 * @journal: journal to startup

 *

 * Locate any valid recovery information from the journal and set up the
@@ -278,7 +278,7 @@ int journal_recover(journal_t *journal) 
 * much recovery information is being erased, and to let us initialise

 * the journal transaction sequence numbers to the next unused ID.

 */

int journal_skip_recovery(journal_t *journal)

int jbd2_journal_skip_recovery(journal_t *journal)

{

	int			err;

	journal_superblock_t *	sb;
@@ -387,7 +387,7 @@ static int do_one_pass(journal_t *journal, 


		tmp = (journal_header_t *)bh->b_data;



		if (tmp->h_magic != cpu_to_be32(JFS_MAGIC_NUMBER)) {

		if (tmp->h_magic != cpu_to_be32(JBD2_MAGIC_NUMBER)) {

			brelse(bh);

			break;

		}
@@ -407,7 +407,7 @@ static int do_one_pass(journal_t *journal, 
		 * to do with it?  That depends on the pass... */



		switch(blocktype) {

		case JFS_DESCRIPTOR_BLOCK:

		case JBD2_DESCRIPTOR_BLOCK:

			/* If it is a valid descriptor block, replay it

			 * in pass REPLAY; otherwise, just skip over the

			 * blocks it describes. */
@@ -451,7 +451,7 @@ static int do_one_pass(journal_t *journal, 
					/* If the block has been

					 * revoked, then we're all done

					 * here. */

					if (journal_test_revoke

					if (jbd2_journal_test_revoke

					    (journal, blocknr,

					     next_commit_ID)) {

						brelse(obh);
@@ -477,9 +477,9 @@ static int do_one_pass(journal_t *journal, 
					lock_buffer(nbh);

					memcpy(nbh->b_data, obh->b_data,

							journal->j_blocksize);

					if (flags & JFS_FLAG_ESCAPE) {

					if (flags & JBD2_FLAG_ESCAPE) {

						*((__be32 *)bh->b_data) =

						cpu_to_be32(JFS_MAGIC_NUMBER);

						cpu_to_be32(JBD2_MAGIC_NUMBER);

					}



					BUFFER_TRACE(nbh, "marking dirty");
@@ -495,17 +495,17 @@ static int do_one_pass(journal_t *journal, 


			skip_write:

				tagp += sizeof(journal_block_tag_t);

				if (!(flags & JFS_FLAG_SAME_UUID))

				if (!(flags & JBD2_FLAG_SAME_UUID))

					tagp += 16;



				if (flags & JFS_FLAG_LAST_TAG)

				if (flags & JBD2_FLAG_LAST_TAG)

					break;

			}



			brelse(bh);

			continue;



		case JFS_COMMIT_BLOCK:

		case JBD2_COMMIT_BLOCK:

			/* Found an expected commit block: not much to

			 * do other than move on to the next sequence

			 * number. */
@@ -513,7 +513,7 @@ static int do_one_pass(journal_t *journal, 
			next_commit_ID++;

			continue;



		case JFS_REVOKE_BLOCK:

		case JBD2_REVOKE_BLOCK:

			/* If we aren't in the REVOKE pass, then we can

			 * just skip over this block. */

			if (pass != PASS_REVOKE) {
@@ -570,11 +570,11 @@ static int do_one_pass(journal_t *journal, 
static int scan_revoke_records(journal_t *journal, struct buffer_head *bh,

			       tid_t sequence, struct recovery_info *info)

{

	journal_revoke_header_t *header;

	jbd2_journal_revoke_header_t *header;

	int offset, max;



	header = (journal_revoke_header_t *) bh->b_data;

	offset = sizeof(journal_revoke_header_t);

	header = (jbd2_journal_revoke_header_t *) bh->b_data;

	offset = sizeof(jbd2_journal_revoke_header_t);

	max = be32_to_cpu(header->r_count);



	while (offset < max) {
@@ -583,7 +583,7 @@ static int scan_revoke_records(journal_t *journal, struct buffer_head *bh, 


		blocknr = be32_to_cpu(* ((__be32 *) (bh->b_data+offset)));

		offset += 4;

		err = journal_set_revoke(journal, blocknr, sequence);

		err = jbd2_journal_set_revoke(journal, blocknr, sequence);

		if (err)

			return err;

		++info->nr_revokes;