jbd: Split updating of journal superblock and marking journal empty (9754e39c) · Commits · e / devices / android_kernel_teracube_emerald

fs/jbd/checkpoint.c

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -540,7 +540,7 @@ int cleanup_journal_tail(journal_t *journal)
	journal->j_tail = blocknr;		journal->j_tail = blocknr;
	spin_unlock(&journal->j_state_lock);		spin_unlock(&journal->j_state_lock);
	if (!(journal->j_flags & JFS_ABORT))		if (!(journal->j_flags & JFS_ABORT))
	journal_update_superblock(journal, 1);		journal_update_sb_log_tail(journal);
	return 0;		return 0;
	}		}

fs/jbd/commit.c

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -308,7 +308,7 @@ void journal_commit_transaction(journal_t *journal)
	/* Do we need to erase the effects of a prior journal_flush? */		/* Do we need to erase the effects of a prior journal_flush? */
	if (journal->j_flags & JFS_FLUSHED) {		if (journal->j_flags & JFS_FLUSHED) {
	jbd_debug(3, "super block updated\n");		jbd_debug(3, "super block updated\n");
	journal_update_superblock(journal, 1);		journal_update_sb_log_tail(journal);
	} else {		} else {
	jbd_debug(3, "superblock not updated\n");		jbd_debug(3, "superblock not updated\n");
	}		}

fs/jbd/journal.c

+97 −67

Original line number	Original line	Diff line number	Diff line
	@@ -923,8 +923,22 @@ static int journal_reset(journal_t *journal)

	journal->j_max_transaction_buffers = journal->j_maxlen / 4;		journal->j_max_transaction_buffers = journal->j_maxlen / 4;

			/*
			* As a special case, if the on-disk copy is already marked as needing
			* no recovery (s_start == 0), then we can safely defer the superblock
			* update until the next commit by setting JFS_FLUSHED. This avoids
			* attempting a write to a potential-readonly device.
			*/
			if (sb->s_start == 0) {
			jbd_debug(1,"JBD: Skipping superblock update on recovered sb "
			"(start %u, seq %d, errno %d)\n",
			journal->j_tail, journal->j_tail_sequence,
			journal->j_errno);
			journal->j_flags \|= JFS_FLUSHED;
			} else {
	/* Add the dynamic fields and write it to disk. */		/* Add the dynamic fields and write it to disk. */
	journal_update_superblock(journal, 1);		journal_update_sb_log_tail(journal);
			}
	return journal_start_thread(journal);		return journal_start_thread(journal);
	}		}

	@@ -1001,35 +1015,11 @@ int journal_create(journal_t *journal)
	return journal_reset(journal);		return journal_reset(journal);
	}		}

	/**		static void journal_write_superblock(journal_t *journal)
	* void journal_update_superblock() - Update journal sb on disk.
	* @journal: The journal to update.
	* @wait: Set to '0' if you don't want to wait for IO completion.
	*
	* Update a journal's dynamic superblock fields and write it to disk,
	* optionally waiting for the IO to complete.
	*/
	void journal_update_superblock(journal_t *journal, int wait)
	{		{
	journal_superblock_t *sb = journal->j_superblock;
	struct buffer_head *bh = journal->j_sb_buffer;		struct buffer_head *bh = journal->j_sb_buffer;

	/*		trace_journal_write_superblock(journal);
	* As a special case, if the on-disk copy is already marked as needing
	* no recovery (s_start == 0) and there are no outstanding transactions
	* in the filesystem, then we can safely defer the superblock update
	* until the next commit by setting JFS_FLUSHED. This avoids
	* attempting a write to a potential-readonly device.
	*/
	if (sb->s_start == 0 && journal->j_tail_sequence ==
	journal->j_transaction_sequence) {
	jbd_debug(1,"JBD: Skipping superblock update on recovered sb "
	"(start %u, seq %d, errno %d)\n",
	journal->j_tail, journal->j_tail_sequence,
	journal->j_errno);
	goto out;
	}

	if (buffer_write_io_error(bh)) {		if (buffer_write_io_error(bh)) {
	char b[BDEVNAME_SIZE];		char b[BDEVNAME_SIZE];
	/*		/*
	@@ -1047,18 +1037,8 @@ void journal_update_superblock(journal_t *journal, int wait)
	set_buffer_uptodate(bh);		set_buffer_uptodate(bh);
	}		}

	spin_lock(&journal->j_state_lock);
	jbd_debug(1,"JBD: updating superblock (start %u, seq %d, errno %d)\n",
	journal->j_tail, journal->j_tail_sequence, journal->j_errno);

	sb->s_sequence = cpu_to_be32(journal->j_tail_sequence);
	sb->s_start = cpu_to_be32(journal->j_tail);
	sb->s_errno = cpu_to_be32(journal->j_errno);
	spin_unlock(&journal->j_state_lock);

	BUFFER_TRACE(bh, "marking dirty");		BUFFER_TRACE(bh, "marking dirty");
	mark_buffer_dirty(bh);		mark_buffer_dirty(bh);
	if (wait) {
	sync_dirty_buffer(bh);		sync_dirty_buffer(bh);
	if (buffer_write_io_error(bh)) {		if (buffer_write_io_error(bh)) {
	char b[BDEVNAME_SIZE];		char b[BDEVNAME_SIZE];
	@@ -1068,23 +1048,83 @@ void journal_update_superblock(journal_t *journal, int wait)
	clear_buffer_write_io_error(bh);		clear_buffer_write_io_error(bh);
	set_buffer_uptodate(bh);		set_buffer_uptodate(bh);
	}		}
	} else		}
	write_dirty_buffer(bh, WRITE);

	trace_jbd_update_superblock_end(journal, wait);		/**
	out:		* journal_update_sb_log_tail() - Update log tail in journal sb on disk.
	/* If we have just flushed the log (by marking s_start==0), then		* @journal: The journal to update.
	* any future commit will have to be careful to update the		*
	* superblock again to re-record the true start of the log. */		* Update a journal's superblock information about log tail and write it to
			* disk, waiting for the IO to complete.
			*/
			void journal_update_sb_log_tail(journal_t *journal)
			{
			journal_superblock_t *sb = journal->j_superblock;

			spin_lock(&journal->j_state_lock);
			jbd_debug(1,"JBD: updating superblock (start %u, seq %d, errno %d)\n",
			journal->j_tail, journal->j_tail_sequence, journal->j_errno);

			sb->s_sequence = cpu_to_be32(journal->j_tail_sequence);
			sb->s_start = cpu_to_be32(journal->j_tail);
			spin_unlock(&journal->j_state_lock);

			journal_write_superblock(journal);

			/* Log is no longer empty */
	spin_lock(&journal->j_state_lock);		spin_lock(&journal->j_state_lock);
	if (sb->s_start)		WARN_ON(!sb->s_sequence);
	journal->j_flags &= ~JFS_FLUSHED;		journal->j_flags &= ~JFS_FLUSHED;
	else		spin_unlock(&journal->j_state_lock);
			}

			/**
			* mark_journal_empty() - Mark on disk journal as empty.
			* @journal: The journal to update.
			*
			* Update a journal's dynamic superblock fields to show that journal is empty.
			* Write updated superblock to disk waiting for IO to complete.
			*/
			static void mark_journal_empty(journal_t *journal)
			{
			journal_superblock_t *sb = journal->j_superblock;

			spin_lock(&journal->j_state_lock);
			jbd_debug(1, "JBD: Marking journal as empty (seq %d)\n",
			journal->j_tail_sequence);

			sb->s_sequence = cpu_to_be32(journal->j_tail_sequence);
			sb->s_start = cpu_to_be32(0);
			spin_unlock(&journal->j_state_lock);

			journal_write_superblock(journal);

			spin_lock(&journal->j_state_lock);
			/* Log is empty */
	journal->j_flags \|= JFS_FLUSHED;		journal->j_flags \|= JFS_FLUSHED;
	spin_unlock(&journal->j_state_lock);		spin_unlock(&journal->j_state_lock);
	}		}

			/**
			* journal_update_sb_errno() - Update error in the journal.
			* @journal: The journal to update.
			*
			* Update a journal's errno. Write updated superblock to disk waiting for IO
			* to complete.
			*/
			static void journal_update_sb_errno(journal_t *journal)
			{
			journal_superblock_t *sb = journal->j_superblock;

			spin_lock(&journal->j_state_lock);
			jbd_debug(1, "JBD: updating superblock error (errno %d)\n",
			journal->j_errno);
			sb->s_errno = cpu_to_be32(journal->j_errno);
			spin_unlock(&journal->j_state_lock);

			journal_write_superblock(journal);
			}

	/*		/*
	* Read the superblock for a given journal, performing initial		* Read the superblock for a given journal, performing initial
	* validation of the format.		* validation of the format.
	@@ -1268,14 +1308,11 @@ int journal_destroy(journal_t *journal)

	if (journal->j_sb_buffer) {		if (journal->j_sb_buffer) {
	if (!is_journal_aborted(journal)) {		if (!is_journal_aborted(journal)) {
	/* We can now mark the journal as empty. */
	journal->j_tail = 0;
	journal->j_tail_sequence =		journal->j_tail_sequence =
	++journal->j_transaction_sequence;		++journal->j_transaction_sequence;
	journal_update_superblock(journal, 1);		mark_journal_empty(journal);
	} else {		} else
	err = -EIO;		err = -EIO;
	}
	brelse(journal->j_sb_buffer);		brelse(journal->j_sb_buffer);
	}		}

	@@ -1457,7 +1494,6 @@ int journal_flush(journal_t *journal)
	{		{
	int err = 0;		int err = 0;
	transaction_t *transaction = NULL;		transaction_t *transaction = NULL;
	unsigned int old_tail;

	spin_lock(&journal->j_state_lock);		spin_lock(&journal->j_state_lock);

	@@ -1499,14 +1535,8 @@ int journal_flush(journal_t *journal)
	* the magic code for a fully-recovered superblock. Any future		* the magic code for a fully-recovered superblock. Any future
	* commits of data to the journal will restore the current		* commits of data to the journal will restore the current
	* s_start value. */		* s_start value. */
			mark_journal_empty(journal);
	spin_lock(&journal->j_state_lock);		spin_lock(&journal->j_state_lock);
	old_tail = journal->j_tail;
	journal->j_tail = 0;
	spin_unlock(&journal->j_state_lock);
	journal_update_superblock(journal, 1);
	spin_lock(&journal->j_state_lock);
	journal->j_tail = old_tail;

	J_ASSERT(!journal->j_running_transaction);		J_ASSERT(!journal->j_running_transaction);
	J_ASSERT(!journal->j_committing_transaction);		J_ASSERT(!journal->j_committing_transaction);
	J_ASSERT(!journal->j_checkpoint_transactions);		J_ASSERT(!journal->j_checkpoint_transactions);
	@@ -1547,7 +1577,7 @@ int journal_wipe(journal_t *journal, int write)

	err = journal_skip_recovery(journal);		err = journal_skip_recovery(journal);
	if (write)		if (write)
	journal_update_superblock(journal, 1);		mark_journal_empty(journal);

	no_recovery:		no_recovery:
	return err;		return err;
	@@ -1615,7 +1645,7 @@ static void __journal_abort_soft (journal_t *journal, int errno)
	__journal_abort_hard(journal);		__journal_abort_hard(journal);

	if (errno)		if (errno)
	journal_update_superblock(journal, 1);		journal_update_sb_errno(journal);
	}		}

	/**		/**

include/linux/jbd.h

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -864,7 +864,7 @@ extern int journal_destroy (journal_t *);
	extern int journal_recover (journal_t *journal);		extern int journal_recover (journal_t *journal);
	extern int journal_wipe (journal_t *, int);		extern int journal_wipe (journal_t *, int);
	extern int journal_skip_recovery (journal_t *);		extern int journal_skip_recovery (journal_t *);
	extern void journal_update_superblock (journal_t *, int);		extern void journal_update_sb_log_tail (journal_t *);
	extern void journal_abort (journal_t *, int);		extern void journal_abort (journal_t *, int);
	extern int journal_errno (journal_t *);		extern int journal_errno (journal_t *);
	extern void journal_ack_err (journal_t *);		extern void journal_ack_err (journal_t *);

include/trace/events/jbd.h

+4 −8

Original line number	Original line	Diff line number	Diff line
	@@ -169,24 +169,20 @@ TRACE_EVENT(jbd_cleanup_journal_tail,
	__entry->block_nr, __entry->freed)		__entry->block_nr, __entry->freed)
	);		);

	TRACE_EVENT(jbd_update_superblock_end,		TRACE_EVENT(journal_write_superblock,
	TP_PROTO(journal_t *journal, int wait),		TP_PROTO(journal_t *journal),

	TP_ARGS(journal, wait),		TP_ARGS(journal),

	TP_STRUCT__entry(		TP_STRUCT__entry(
	__field( dev_t, dev )		__field( dev_t, dev )
	__field( int, wait )
	),		),

	TP_fast_assign(		TP_fast_assign(
	__entry->dev = journal->j_fs_dev->bd_dev;		__entry->dev = journal->j_fs_dev->bd_dev;
	__entry->wait = wait;
	),		),

	TP_printk("dev %d,%d wait %d",		TP_printk("dev %d,%d", MAJOR(__entry->dev), MINOR(__entry->dev))
	MAJOR(__entry->dev), MINOR(__entry->dev),
	__entry->wait)
	);		);

	#endif /* _TRACE_JBD_H */		#endif /* _TRACE_JBD_H */