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

Commit 93806299 authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Darrick J. Wong
Browse files

xfs: refactor xfs_log_force_lsn 



Use the the smallest possible loop as preable to find the correct iclog
buffer, and then use gotos for unwinding to straighten the code.

Also fix the top of function comment while we're at it.

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarDarrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: default avatarDarrick J. Wong <darrick.wong@oracle.com>
parent df79b81b

fs/xfs/xfs_log.c

+62 −80
Original line number Diff line number Diff line
@@ -3404,11 +3404,10 @@ xfs_log_force( 
 *		state and go to sleep or return.

 *	If it is in any other state, go to sleep or return.

 *

 * Synchronous forces are implemented with a signal variable. All callers

 * to force a given lsn to disk will wait on a the sv attached to the

 * specific in-core log.  When given in-core log finally completes its

 * write to disk, that thread will wake up all threads waiting on the

 * sv.

 * Synchronous forces are implemented with a wait queue.  All callers trying

 * to force a given lsn to disk must wait on the queue attached to the

 * specific in-core log.  When given in-core log finally completes its write

 * to disk, that thread will wake up all threads waiting on the queue.

 */

int

xfs_log_force_lsn(
@@ -3433,40 +3432,33 @@ xfs_log_force_lsn( 
try_again:

	spin_lock(&log->l_icloglock);

	iclog = log->l_iclog;

	if (iclog->ic_state & XLOG_STATE_IOERROR) {

		spin_unlock(&log->l_icloglock);

		return -EIO;

	}

	if (iclog->ic_state & XLOG_STATE_IOERROR)

		goto out_error;



	do {

		if (be64_to_cpu(iclog->ic_header.h_lsn) != lsn) {

	while (be64_to_cpu(iclog->ic_header.h_lsn) != lsn) {

		iclog = iclog->ic_next;

			continue;

		if (iclog == log->l_iclog)

			goto out_unlock;

	}



		if (iclog->ic_state == XLOG_STATE_DIRTY) {

			spin_unlock(&log->l_icloglock);

			return 0;

		}

	if (iclog->ic_state == XLOG_STATE_DIRTY)

		goto out_unlock;



	if (iclog->ic_state == XLOG_STATE_ACTIVE) {

		/*

			 * We sleep here if we haven't already slept (e.g.

			 * this is the first time we've looked at the correct

			 * iclog buf) and the buffer before us is going to

			 * be sync'ed. The reason for this is that if we

			 * are doing sync transactions here, by waiting for

			 * the previous I/O to complete, we can allow a few

			 * more transactions into this iclog before we close

			 * it down.

		 * We sleep here if we haven't already slept (e.g. this is the

		 * first time we've looked at the correct iclog buf) and the

		 * buffer before us is going to be sync'ed.  The reason for this

		 * is that if we are doing sync transactions here, by waiting

		 * for the previous I/O to complete, we can allow a few more

		 * transactions into this iclog before we close it down.

		 *

			 * Otherwise, we mark the buffer WANT_SYNC, and bump

			 * up the refcnt so we can release the log (which

			 * drops the ref count).  The state switch keeps new

			 * transaction commits from using this buffer.  When

			 * the current commits finish writing into the buffer,

			 * the refcount will drop to zero and the buffer will

			 * go out then.

		 * Otherwise, we mark the buffer WANT_SYNC, and bump up the

		 * refcnt so we can release the log (which drops the ref count).

		 * The state switch keeps new transaction commits from using

		 * this buffer.  When the current commits finish writing into

		 * the buffer, the refcount will drop to zero and the buffer

		 * will go out then.

		 */

		if (!already_slept &&

		    (iclog->ic_prev->ic_state &
@@ -3490,35 +3482,25 @@ xfs_log_force_lsn( 
		spin_lock(&log->l_icloglock);

	}



		if ((flags & XFS_LOG_SYNC) && /* sleep */

		    !(iclog->ic_state &

		      (XLOG_STATE_ACTIVE | XLOG_STATE_DIRTY))) {

			/*

			 * Don't wait on completion if we know that we've

			 * gotten a log write error.

			 */

			if (iclog->ic_state & XLOG_STATE_IOERROR) {

				spin_unlock(&log->l_icloglock);

				return -EIO;

			}

	if (!(flags & XFS_LOG_SYNC) ||

	    (iclog->ic_state & (XLOG_STATE_ACTIVE | XLOG_STATE_DIRTY)))

		goto out_unlock;



	if (iclog->ic_state & XLOG_STATE_IOERROR)

		goto out_error;



	XFS_STATS_INC(mp, xs_log_force_sleep);

	xlog_wait(&iclog->ic_force_wait, &log->l_icloglock);

			/*

			 * No need to grab the log lock here since we're

			 * only deciding whether or not to return EIO

			 * and the memory read should be atomic.

			 */

	if (iclog->ic_state & XLOG_STATE_IOERROR)

		return -EIO;

		} else {		/* just return */

			spin_unlock(&log->l_icloglock);

		}



	return 0;

	} while (iclog != log->l_iclog);



out_unlock:

	spin_unlock(&log->l_icloglock);

	return 0;

out_error:

	spin_unlock(&log->l_icloglock);

	return -EIO;

}



/*