korg/linux
0
0
Fork 0
mirror of https://mirrors.bfsu.edu.cn/git/linux.git synced 2024-12-04 09:34:12 +08:00
Code Issues Packages Projects Releases Wiki Activity

xfs: move recovery needed state updates to xfs_log_mount_finish

Browse Source 
xfs_log_mount_finish() needs to know if recovery is needed or not to
make decisions on whether to flush the log and AIL.  Move the
handling of the NEED_RECOVERY state out to this function rather than
needing a temporary variable to store this state over the call to
xlog_recover_finish().

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
This commit is contained in:
Dave Chinner 2021-08-10 17:59:02 -07:00 committed by Darrick J. Wong
parent 5112e2067b
commit fd67d8a072
2 changed files with 58 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
fs/xfs/xfs_log.c
View File

@ -726,9 +726,9 @@ int
xfs_log_mount_finish(
struct xfs_mount *mp)
{
int error = 0;
bool readonly = (mp->m_flags & XFS_MOUNT_RDONLY);
bool recovered = mp->m_log->l_flags & XLOG_RECOVERY_NEEDED;
struct xlog *log = mp->m_log;
bool readonly = (mp->m_flags & XFS_MOUNT_RDONLY);
int error = 0;
if (mp->m_flags & XFS_MOUNT_NORECOVERY) {
ASSERT(mp->m_flags & XFS_MOUNT_RDONLY);
@ -759,7 +759,8 @@ xfs_log_mount_finish(
* mount failure occurs.
*/
mp->m_super->s_flags |= SB_ACTIVE;
error = xlog_recover_finish(mp->m_log);
if (log->l_flags & XLOG_RECOVERY_NEEDED)
error = xlog_recover_finish(log);
if (!error)
xfs_log_work_queue(mp);
mp->m_super->s_flags &= ~SB_ACTIVE;
@ -774,17 +775,24 @@ xfs_log_mount_finish(
* Don't push in the error case because the AIL may have pending intents
* that aren't removed until recovery is cancelled.
*/
if (!error && recovered) {
xfs_log_force(mp, XFS_LOG_SYNC);
xfs_ail_push_all_sync(mp->m_ail);
if (log->l_flags & XLOG_RECOVERY_NEEDED) {
if (!error) {
xfs_log_force(mp, XFS_LOG_SYNC);
xfs_ail_push_all_sync(mp->m_ail);
}
xfs_notice(mp, "Ending recovery (logdev: %s)",
mp->m_logname ? mp->m_logname : "internal");
} else {
xfs_info(mp, "Ending clean mount");
}
xfs_buftarg_drain(mp->m_ddev_targp);
log->l_flags &= ~XLOG_RECOVERY_NEEDED;
if (readonly)
mp->m_flags |= XFS_MOUNT_RDONLY;
/* Make sure the log is dead if we're returning failure. */
ASSERT(!error || (mp->m_log->l_flags & XLOG_IO_ERROR));
ASSERT(!error || xlog_is_shutdown(log));
return error;
}

104
fs/xfs/xfs_log_recover.c
View File

@ -3449,78 +3449,58 @@ xlog_recover(
}
/*
* In the first part of recovery we replay inodes and buffers and build
* up the list of extent free items which need to be processed. Here
* we process the extent free items and clean up the on disk unlinked
* inode lists. This is separated from the first part of recovery so
* that the root and real-time bitmap inodes can be read in from disk in
* between the two stages. This is necessary so that we can free space
* in the real-time portion of the file system.
* In the first part of recovery we replay inodes and buffers and build up the
* list of intents which need to be processed. Here we process the intents and
* clean up the on disk unlinked inode lists. This is separated from the first
* part of recovery so that the root and real-time bitmap inodes can be read in
* from disk in between the two stages. This is necessary so that we can free
* space in the real-time portion of the file system.
*/
int
xlog_recover_finish(
struct xlog *log)
{
int error;
error = xlog_recover_process_intents(log);
if (error) {
/*
* Cancel all the unprocessed intent items now so that we don't
* leave them pinned in the AIL. This can cause the AIL to
* livelock on the pinned item if anyone tries to push the AIL
* (inode reclaim does this) before we get around to
* xfs_log_mount_cancel.
*/
xlog_recover_cancel_intents(log);
xfs_alert(log->l_mp, "Failed to recover intents");
xfs_force_shutdown(log->l_mp, SHUTDOWN_LOG_IO_ERROR);
return error;
}
/*
* Now we're ready to do the transactions needed for the
* rest of recovery. Start with completing all the extent
* free intent records and then process the unlinked inode
* lists. At this point, we essentially run in normal mode
* except that we're still performing recovery actions
* rather than accepting new requests.
* Sync the log to get all the intents out of the AIL. This isn't
* absolutely necessary, but it helps in case the unlink transactions
* would have problems pushing the intents out of the way.
*/
if (log->l_flags & XLOG_RECOVERY_NEEDED) {
int error;
error = xlog_recover_process_intents(log);
if (error) {
/*
* Cancel all the unprocessed intent items now so that
* we don't leave them pinned in the AIL. This can
* cause the AIL to livelock on the pinned item if
* anyone tries to push the AIL (inode reclaim does
* this) before we get around to xfs_log_mount_cancel.
*/
xlog_recover_cancel_intents(log);
xfs_force_shutdown(log->l_mp, SHUTDOWN_LOG_IO_ERROR);
xfs_alert(log->l_mp, "Failed to recover intents");
xfs_log_force(log->l_mp, XFS_LOG_SYNC);
/*
* Now that we've recovered the log and all the intents, we can clear
* the log incompat feature bits in the superblock because there's no
* longer anything to protect. We rely on the AIL push to write out the
* updated superblock after everything else.
*/
if (xfs_clear_incompat_log_features(log->l_mp)) {
error = xfs_sync_sb(log->l_mp, false);
if (error < 0) {
xfs_alert(log->l_mp,
"Failed to clear log incompat features on recovery");
return error;
}
/*
* Sync the log to get all the intents out of the AIL.
* This isn't absolutely necessary, but it helps in
* case the unlink transactions would have problems
* pushing the intents out of the way.
*/
xfs_log_force(log->l_mp, XFS_LOG_SYNC);
/*
* Now that we've recovered the log and all the intents, we can
* clear the log incompat feature bits in the superblock
* because there's no longer anything to protect. We rely on
* the AIL push to write out the updated superblock after
* everything else.
*/
if (xfs_clear_incompat_log_features(log->l_mp)) {
error = xfs_sync_sb(log->l_mp, false);
if (error < 0) {
xfs_alert(log->l_mp,
"Failed to clear log incompat features on recovery");
return error;
}
}
xlog_recover_process_iunlinks(log);
xlog_recover_check_summary(log);
xfs_notice(log->l_mp, "Ending recovery (logdev: %s)",
log->l_mp->m_logname ? log->l_mp->m_logname
: "internal");
log->l_flags &= ~XLOG_RECOVERY_NEEDED;
} else {
xfs_info(log->l_mp, "Ending clean mount");
}
xlog_recover_process_iunlinks(log);
xlog_recover_check_summary(log);
return 0;
}