xfs: move recovery needed state updates to xfs_log_mount_finish

[sfrench/cifs-2.6.git] / fs / xfs / xfs_log_recover.c

diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index e6589cf4d09fec3376e86d69f30060d346627999..53006e923a8cc63cb818acfbb799c1daf1e9facd 100644 (file)
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -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)
 {
-       /*
-        * 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.
-                        */
-                       xlog_recover_cancel_intents(log);
-                       xfs_force_shutdown(log->l_mp, SHUTDOWN_LOG_IO_ERROR);
-                       xfs_alert(log->l_mp, "Failed to recover intents");
-                       return error;
-               }
+       int     error;
 
+       error = xlog_recover_process_intents(log);
+       if (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.
+                * 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.
                 */
-               xfs_log_force(log->l_mp, XFS_LOG_SYNC);
+               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 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,
+       /*
+        * 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;
-                       }
+                       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;
 }