xfs: move recovery needed state updates to xfs_log_mount_finish

xfs_log_mount_finish(

	struct xfs_mount	*mp)

{

	int	error = 0;

	struct xlog		*log = mp->m_log;

	bool			readonly = (mp->m_flags & XFS_MOUNT_RDONLY);

	bool	recovered = mp->m_log->l_flags & XLOG_RECOVERY_NEEDED;

	int			error = 0;

	if (mp->m_flags & XFS_MOUNT_NORECOVERY) {

		ASSERT(mp->m_flags & XFS_MOUNT_RDONLY);

	 * 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;

	 * 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) {

	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;

}

}

/*

 * 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)

{

	/*

	 * 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.

	 */

	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.

		 * 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_force_shutdown(log->l_mp, SHUTDOWN_LOG_IO_ERROR);

		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.

	 * 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.

	 * 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);

	}

	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");

	}

	return 0;

}