Commit de302cea authored by Dave Chinner's avatar Dave Chinner Committed by Chandan Babu R
Browse files

xfs: pass the full grant head to accounting functions 



Because we are going to need them soon. API change only, no logic
changes.

Signed-off-by: default avatarDave Chinner <dchinner@redhat.com>
Reviewed-by: default avatarDarrick J. Wong <djwong@kernel.org>
Reviewed-by: default avatarChristoph Hellwig <hch@lst.de>
Signed-off-by: default avatarChandan Babu R <chandanbabu@kernel.org>
parent 551bf13b

fs/xfs/xfs_log.c

+77 −80
Original line number Diff line number Diff line
@@ -136,10 +136,10 @@ xlog_prepare_iovec( 
static void

xlog_grant_sub_space(

	struct xlog		*log,

	atomic64_t		*head,

	struct xlog_grant_head	*head,

	int			bytes)

{

	int64_t	head_val = atomic64_read(head);

	int64_t	head_val = atomic64_read(&head->grant);

	int64_t new, old;



	do {
@@ -155,17 +155,17 @@ xlog_grant_sub_space( 


		old = head_val;

		new = xlog_assign_grant_head_val(cycle, space);

		head_val = atomic64_cmpxchg(head, old, new);

		head_val = atomic64_cmpxchg(&head->grant, old, new);

	} while (head_val != old);

}



static void

xlog_grant_add_space(

	struct xlog		*log,

	atomic64_t		*head,

	struct xlog_grant_head	*head,

	int			bytes)

{

	int64_t	head_val = atomic64_read(head);

	int64_t	head_val = atomic64_read(&head->grant);

	int64_t new, old;



	do {
@@ -184,7 +184,7 @@ xlog_grant_add_space( 


		old = head_val;

		new = xlog_assign_grant_head_val(cycle, space);

		head_val = atomic64_cmpxchg(head, old, new);

		head_val = atomic64_cmpxchg(&head->grant, old, new);

	} while (head_val != old);

}
@@ -197,6 +197,63 @@ xlog_grant_head_init( 
	spin_lock_init(&head->lock);

}



/*

 * Return the space in the log between the tail and the head.  The head

 * is passed in the cycle/bytes formal parms.  In the special case where

 * the reserve head has wrapped passed the tail, this calculation is no

 * longer valid.  In this case, just return 0 which means there is no space

 * in the log.  This works for all places where this function is called

 * with the reserve head.  Of course, if the write head were to ever

 * wrap the tail, we should blow up.  Rather than catch this case here,

 * we depend on other ASSERTions in other parts of the code.   XXXmiken

 *

 * If reservation head is behind the tail, we have a problem. Warn about it,

 * but then treat it as if the log is empty.

 *

 * If the log is shut down, the head and tail may be invalid or out of whack, so

 * shortcut invalidity asserts in this case so that we don't trigger them

 * falsely.

 */

static int

xlog_grant_space_left(

	struct xlog		*log,

	struct xlog_grant_head	*head)

{

	int			tail_bytes;

	int			tail_cycle;

	int			head_cycle;

	int			head_bytes;



	xlog_crack_grant_head(&head->grant, &head_cycle, &head_bytes);

	xlog_crack_atomic_lsn(&log->l_tail_lsn, &tail_cycle, &tail_bytes);

	tail_bytes = BBTOB(tail_bytes);

	if (tail_cycle == head_cycle && head_bytes >= tail_bytes)

		return log->l_logsize - (head_bytes - tail_bytes);

	if (tail_cycle + 1 < head_cycle)

		return 0;



	/* Ignore potential inconsistency when shutdown. */

	if (xlog_is_shutdown(log))

		return log->l_logsize;



	if (tail_cycle < head_cycle) {

		ASSERT(tail_cycle == (head_cycle - 1));

		return tail_bytes - head_bytes;

	}



	/*

	 * The reservation head is behind the tail. In this case we just want to

	 * return the size of the log as the amount of space left.

	 */

	xfs_alert(log->l_mp, "xlog_grant_space_left: head behind tail");

	xfs_alert(log->l_mp, "  tail_cycle = %d, tail_bytes = %d",

		  tail_cycle, tail_bytes);

	xfs_alert(log->l_mp, "  GH   cycle = %d, GH   bytes = %d",

		  head_cycle, head_bytes);

	ASSERT(0);

	return log->l_logsize;

}



STATIC void

xlog_grant_head_wake_all(

	struct xlog_grant_head	*head)
@@ -277,7 +334,7 @@ xlog_grant_head_wait( 
		spin_lock(&head->lock);

		if (xlog_is_shutdown(log))

			goto shutdown;

	} while (xlog_space_left(log, &head->grant) < need_bytes);

	} while (xlog_grant_space_left(log, head) < need_bytes);



	list_del_init(&tic->t_queue);

	return 0;
@@ -322,7 +379,7 @@ xlog_grant_head_check( 
	 * otherwise try to get some space for this transaction.

	 */

	*need_bytes = xlog_ticket_reservation(log, head, tic);

	free_bytes = xlog_space_left(log, &head->grant);

	free_bytes = xlog_grant_space_left(log, head);

	if (!list_empty_careful(&head->waiters)) {

		spin_lock(&head->lock);

		if (!xlog_grant_head_wake(log, head, &free_bytes) ||
@@ -396,7 +453,7 @@ xfs_log_regrant( 
	if (error)

		goto out_error;



	xlog_grant_add_space(log, &log->l_write_head.grant, need_bytes);

	xlog_grant_add_space(log, &log->l_write_head, need_bytes);

	trace_xfs_log_regrant_exit(log, tic);

	xlog_verify_grant_tail(log);

	return 0;
@@ -447,8 +504,8 @@ xfs_log_reserve( 
	if (error)

		goto out_error;



	xlog_grant_add_space(log, &log->l_reserve_head.grant, need_bytes);

	xlog_grant_add_space(log, &log->l_write_head.grant, need_bytes);

	xlog_grant_add_space(log, &log->l_reserve_head, need_bytes);

	xlog_grant_add_space(log, &log->l_write_head, need_bytes);

	trace_xfs_log_reserve_exit(log, tic);

	xlog_verify_grant_tail(log);

	return 0;
@@ -1107,7 +1164,7 @@ xfs_log_space_wake( 
		ASSERT(!xlog_in_recovery(log));



		spin_lock(&log->l_write_head.lock);

		free_bytes = xlog_space_left(log, &log->l_write_head.grant);

		free_bytes = xlog_grant_space_left(log, &log->l_write_head);

		xlog_grant_head_wake(log, &log->l_write_head, &free_bytes);

		spin_unlock(&log->l_write_head.lock);

	}
@@ -1116,7 +1173,7 @@ xfs_log_space_wake( 
		ASSERT(!xlog_in_recovery(log));



		spin_lock(&log->l_reserve_head.lock);

		free_bytes = xlog_space_left(log, &log->l_reserve_head.grant);

		free_bytes = xlog_grant_space_left(log, &log->l_reserve_head);

		xlog_grant_head_wake(log, &log->l_reserve_head, &free_bytes);

		spin_unlock(&log->l_reserve_head.lock);

	}
@@ -1230,64 +1287,6 @@ xfs_log_cover( 
	return error;

}



/*

 * Return the space in the log between the tail and the head.  The head

 * is passed in the cycle/bytes formal parms.  In the special case where

 * the reserve head has wrapped passed the tail, this calculation is no

 * longer valid.  In this case, just return 0 which means there is no space

 * in the log.  This works for all places where this function is called

 * with the reserve head.  Of course, if the write head were to ever

 * wrap the tail, we should blow up.  Rather than catch this case here,

 * we depend on other ASSERTions in other parts of the code.   XXXmiken

 *

 * If reservation head is behind the tail, we have a problem. Warn about it,

 * but then treat it as if the log is empty.

 *

 * If the log is shut down, the head and tail may be invalid or out of whack, so

 * shortcut invalidity asserts in this case so that we don't trigger them

 * falsely.

 */

int

xlog_space_left(

	struct xlog	*log,

	atomic64_t	*head)

{

	int		tail_bytes;

	int		tail_cycle;

	int		head_cycle;

	int		head_bytes;



	xlog_crack_grant_head(head, &head_cycle, &head_bytes);

	xlog_crack_atomic_lsn(&log->l_tail_lsn, &tail_cycle, &tail_bytes);

	tail_bytes = BBTOB(tail_bytes);

	if (tail_cycle == head_cycle && head_bytes >= tail_bytes)

		return log->l_logsize - (head_bytes - tail_bytes);

	if (tail_cycle + 1 < head_cycle)

		return 0;



	/* Ignore potential inconsistency when shutdown. */

	if (xlog_is_shutdown(log))

		return log->l_logsize;



	if (tail_cycle < head_cycle) {

		ASSERT(tail_cycle == (head_cycle - 1));

		return tail_bytes - head_bytes;

	}



	/*

	 * The reservation head is behind the tail. In this case we just want to

	 * return the size of the log as the amount of space left.

	 */

	xfs_alert(log->l_mp, "xlog_space_left: head behind tail");

	xfs_alert(log->l_mp, "  tail_cycle = %d, tail_bytes = %d",

		  tail_cycle, tail_bytes);

	xfs_alert(log->l_mp, "  GH   cycle = %d, GH   bytes = %d",

		  head_cycle, head_bytes);

	ASSERT(0);

	return log->l_logsize;

}





static void

xlog_ioend_work(

	struct work_struct	*work)
@@ -1881,8 +1880,8 @@ xlog_sync( 
	if (ticket) {

		ticket->t_curr_res -= roundoff;

	} else {

		xlog_grant_add_space(log, &log->l_reserve_head.grant, roundoff);

		xlog_grant_add_space(log, &log->l_write_head.grant, roundoff);

		xlog_grant_add_space(log, &log->l_reserve_head, roundoff);

		xlog_grant_add_space(log, &log->l_write_head, roundoff);

	}



	/* put cycle number in every block */
@@ -2802,17 +2801,15 @@ xfs_log_ticket_regrant( 
	if (ticket->t_cnt > 0)

		ticket->t_cnt--;



	xlog_grant_sub_space(log, &log->l_reserve_head.grant,

					ticket->t_curr_res);

	xlog_grant_sub_space(log, &log->l_write_head.grant,

					ticket->t_curr_res);

	xlog_grant_sub_space(log, &log->l_reserve_head, ticket->t_curr_res);

	xlog_grant_sub_space(log, &log->l_write_head, ticket->t_curr_res);

	ticket->t_curr_res = ticket->t_unit_res;



	trace_xfs_log_ticket_regrant_sub(log, ticket);



	/* just return if we still have some of the pre-reserved space */

	if (!ticket->t_cnt) {

		xlog_grant_add_space(log, &log->l_reserve_head.grant,

		xlog_grant_add_space(log, &log->l_reserve_head,

				     ticket->t_unit_res);

		trace_xfs_log_ticket_regrant_exit(log, ticket);
@@ -2860,8 +2857,8 @@ xfs_log_ticket_ungrant( 
		bytes += ticket->t_unit_res*ticket->t_cnt;

	}



	xlog_grant_sub_space(log, &log->l_reserve_head.grant, bytes);

	xlog_grant_sub_space(log, &log->l_write_head.grant, bytes);

	xlog_grant_sub_space(log, &log->l_reserve_head, bytes);

	xlog_grant_sub_space(log, &log->l_write_head, bytes);



	trace_xfs_log_ticket_ungrant_exit(log, ticket);

fs/xfs/xfs_log_priv.h

+0 −2
Original line number Diff line number Diff line
@@ -573,8 +573,6 @@ xlog_assign_grant_head(atomic64_t *head, int cycle, int space) 
	atomic64_set(head, xlog_assign_grant_head_val(cycle, space));

}



int xlog_space_left(struct xlog *log, atomic64_t *head);



/*

 * Committed Item List interfaces

 */