Skip to content

Commit

Permalink
xfs: refactor xlog_state_clean_iclog
Browse files Browse the repository at this point in the history 
Factor out a few self-contained helpers from xlog_state_clean_iclog, and
update the documentation so it primarily documents why things happens
instead of how.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
  • Loading branch information
Christoph Hellwig authored and Darrick J. Wong committed Mar 23, 2020
1 parent 12e6a0f commit c814b4f
Showing 1 changed file with 88 additions and 92 deletions.
180 changes: 88 additions & 92 deletions fs/xfs/xfs_log.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2540,111 +2540,107 @@ xlog_write(
*****************************************************************************
*/

static void
xlog_state_activate_iclog(
struct xlog_in_core *iclog,
int *iclogs_changed)
{
ASSERT(list_empty_careful(&iclog->ic_callbacks));

/*
* If the number of ops in this iclog indicate it just contains the
* dummy transaction, we can change state into IDLE (the second time
* around). Otherwise we should change the state into NEED a dummy.
* We don't need to cover the dummy.
*/
if (*iclogs_changed == 0 &&
iclog->ic_header.h_num_logops == cpu_to_be32(XLOG_COVER_OPS)) {
*iclogs_changed = 1;
} else {
/*
* We have two dirty iclogs so start over. This could also be
* num of ops indicating this is not the dummy going out.
*/
*iclogs_changed = 2;
}

iclog->ic_state = XLOG_STATE_ACTIVE;
iclog->ic_offset = 0;
iclog->ic_header.h_num_logops = 0;
memset(iclog->ic_header.h_cycle_data, 0,
sizeof(iclog->ic_header.h_cycle_data));
iclog->ic_header.h_lsn = 0;
}

/*
* An iclog has just finished IO completion processing, so we need to update
* the iclog state and propagate that up into the overall log state. Hence we
* prepare the iclog for cleaning, and then clean all the pending dirty iclogs
* starting from the head, and then wake up any threads that are waiting for the
* iclog to be marked clean.
*
* The ordering of marking iclogs ACTIVE must be maintained, so an iclog
* doesn't become ACTIVE beyond one that is SYNCING. This is also required to
* maintain the notion that we use a ordered wait queue to hold off would be
* writers to the log when every iclog is trying to sync to disk.
*
* Caller must hold the icloglock before calling us.
*
* State Change: !IOERROR -> DIRTY -> ACTIVE
* Loop through all iclogs and mark all iclogs currently marked DIRTY as
* ACTIVE after iclog I/O has completed.
*/
STATIC void
xlog_state_clean_iclog(
static void
xlog_state_activate_iclogs(
struct xlog *log,
struct xlog_in_core *dirty_iclog)
int *iclogs_changed)
{
struct xlog_in_core *iclog;
int changed = 0;

/* Prepare the completed iclog. */
if (dirty_iclog->ic_state != XLOG_STATE_IOERROR)
dirty_iclog->ic_state = XLOG_STATE_DIRTY;
struct xlog_in_core *iclog = log->l_iclog;

/* Walk all the iclogs to update the ordered active state. */
iclog = log->l_iclog;
do {
if (iclog->ic_state == XLOG_STATE_DIRTY) {
iclog->ic_state = XLOG_STATE_ACTIVE;
iclog->ic_offset = 0;
ASSERT(list_empty_careful(&iclog->ic_callbacks));
/*
* If the number of ops in this iclog indicate it just
* contains the dummy transaction, we can
* change state into IDLE (the second time around).
* Otherwise we should change the state into
* NEED a dummy.
* We don't need to cover the dummy.
*/
if (!changed &&
(be32_to_cpu(iclog->ic_header.h_num_logops) ==
XLOG_COVER_OPS)) {
changed = 1;
} else {
/*
* We have two dirty iclogs so start over
* This could also be num of ops indicates
* this is not the dummy going out.
*/
changed = 2;
}
iclog->ic_header.h_num_logops = 0;
memset(iclog->ic_header.h_cycle_data, 0,
sizeof(iclog->ic_header.h_cycle_data));
iclog->ic_header.h_lsn = 0;
} else if (iclog->ic_state == XLOG_STATE_ACTIVE)
/* do nothing */;
else
break; /* stop cleaning */
iclog = iclog->ic_next;
} while (iclog != log->l_iclog);

if (iclog->ic_state == XLOG_STATE_DIRTY)
xlog_state_activate_iclog(iclog, iclogs_changed);
/*
* The ordering of marking iclogs ACTIVE must be maintained, so
* an iclog doesn't become ACTIVE beyond one that is SYNCING.
*/
else if (iclog->ic_state != XLOG_STATE_ACTIVE)
break;
} while ((iclog = iclog->ic_next) != log->l_iclog);
}

static int
xlog_covered_state(
int prev_state,
int iclogs_changed)
{
/*
* Wake up threads waiting in xfs_log_force() for the dirty iclog
* to be cleaned.
* We usually go to NEED. But we go to NEED2 if the changed indicates we
* are done writing the dummy record. If we are done with the second
* dummy recored (DONE2), then we go to IDLE.
*/
wake_up_all(&dirty_iclog->ic_force_wait);
switch (prev_state) {
case XLOG_STATE_COVER_IDLE:
case XLOG_STATE_COVER_NEED:
case XLOG_STATE_COVER_NEED2:
break;
case XLOG_STATE_COVER_DONE:
if (iclogs_changed == 1)
return XLOG_STATE_COVER_NEED2;
break;
case XLOG_STATE_COVER_DONE2:
if (iclogs_changed == 1)
return XLOG_STATE_COVER_IDLE;
break;
default:
ASSERT(0);
}

/*
* Change state for the dummy log recording.
* We usually go to NEED. But we go to NEED2 if the changed indicates
* we are done writing the dummy record.
* If we are done with the second dummy recored (DONE2), then
* we go to IDLE.
*/
if (changed) {
switch (log->l_covered_state) {
case XLOG_STATE_COVER_IDLE:
case XLOG_STATE_COVER_NEED:
case XLOG_STATE_COVER_NEED2:
log->l_covered_state = XLOG_STATE_COVER_NEED;
break;
return XLOG_STATE_COVER_NEED;
}

case XLOG_STATE_COVER_DONE:
if (changed == 1)
log->l_covered_state = XLOG_STATE_COVER_NEED2;
else
log->l_covered_state = XLOG_STATE_COVER_NEED;
break;
STATIC void
xlog_state_clean_iclog(
struct xlog *log,
struct xlog_in_core *dirty_iclog)
{
int iclogs_changed = 0;

case XLOG_STATE_COVER_DONE2:
if (changed == 1)
log->l_covered_state = XLOG_STATE_COVER_IDLE;
else
log->l_covered_state = XLOG_STATE_COVER_NEED;
break;
if (dirty_iclog->ic_state != XLOG_STATE_IOERROR)
dirty_iclog->ic_state = XLOG_STATE_DIRTY;

default:
ASSERT(0);
}
xlog_state_activate_iclogs(log, &iclogs_changed);
wake_up_all(&dirty_iclog->ic_force_wait);

if (iclogs_changed) {
log->l_covered_state = xlog_covered_state(log->l_covered_state,
iclogs_changed);
}
}

Expand Down

0 comments on commit c814b4f

Please sign in to comment.