1 files changed, 19 insertions, 40 deletions

diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index ca4fd5bd8522..fe88ef67f93a 100644
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -1678,7 +1678,7 @@ xlog_bdstrat(
         if (iclog->ic_state & XLOG_STATE_IOERROR) {
                 xfs_buf_ioerror(bp, -EIO);
                 xfs_buf_stale(bp);
-                xfs_buf_ioend(bp, 0);
+                xfs_buf_ioend(bp);
                 /*
                  * It would seem logical to return EIO here, but we rely on
                  * the log state machine to propagate I/O errors instead of
@@ -1688,7 +1688,7 @@ xlog_bdstrat(
                 return 0;
         }
 
-        xfs_buf_iorequest(bp);
+        xfs_buf_submit(bp);
         return 0;
 }
 
@@ -3867,18 +3867,17 @@ xlog_state_ioerror(
  * This is called from xfs_force_shutdown, when we're forcibly
  * shutting down the filesystem, typically because of an IO error.
  * Our main objectives here are to make sure that:
- *      a. the filesystem gets marked 'SHUTDOWN' for all interested
+ *      a. if !logerror, flush the logs to disk. Anything modified
+ *         after this is ignored.
+ *      b. the filesystem gets marked 'SHUTDOWN' for all interested
  *         parties to find out, 'atomically'.
- *      b. those who're sleeping on log reservations, pinned objects and
+ *      c. those who're sleeping on log reservations, pinned objects and
  *          other resources get woken up, and be told the bad news.
- *      c. nothing new gets queued up after (a) and (b) are done.
- *      d. if !logerror, flush the iclogs to disk, then seal them off
- *         for business.
+ *      d. nothing new gets queued up after (b) and (c) are done.
  *
- * Note: for delayed logging the !logerror case needs to flush the regions
- * held in memory out to the iclogs before flushing them to disk. This needs
- * to be done before the log is marked as shutdown, otherwise the flush to the
- * iclogs will fail.
+ * Note: for the !logerror case we need to flush the regions held in memory out
+ * to disk first. This needs to be done before the log is marked as shutdown,
+ * otherwise the iclog writes will fail.
  */
 int
 xfs_log_force_umount(
@@ -3910,16 +3909,16 @@ xfs_log_force_umount(
                 ASSERT(XLOG_FORCED_SHUTDOWN(log));
                 return 1;
         }
-        retval = 0;
 
         /*
-         * Flush the in memory commit item list before marking the log as
-         * being shut down. We need to do it in this order to ensure all the
-         * completed transactions are flushed to disk with the xfs_log_force()
-         * call below.
+         * Flush all the completed transactions to disk before marking the log
+         * being shut down. We need to do it in this order to ensure that
+         * completed operations are safely on disk before we shut down, and that
+         * we don't have to issue any buffer IO after the shutdown flags are set
+         * to guarantee this.
          */
         if (!logerror)
-                xlog_cil_force(log);
+                _xfs_log_force(mp, XFS_LOG_SYNC, NULL);
 
         /*
          * mark the filesystem and the as in a shutdown state and wake
@@ -3931,18 +3930,11 @@ xfs_log_force_umount(
                 XFS_BUF_DONE(mp->m_sb_bp);
 
         /*
-         * This flag is sort of redundant because of the mount flag, but
-         * it's good to maintain the separation between the log and the rest
-         * of XFS.
+         * Mark the log and the iclogs with IO error flags to prevent any
+         * further log IO from being issued or completed.
          */
         log->l_flags |= XLOG_IO_ERROR;
-
-        /*
-         * If we hit a log error, we want to mark all the iclogs IOERROR
-         * while we're still holding the loglock.
-         */
-        if (logerror)
-                retval = xlog_state_ioerror(log);
+        retval = xlog_state_ioerror(log);
         spin_unlock(&log->l_icloglock);
 
         /*
@@ -3955,19 +3947,6 @@ xfs_log_force_umount(
         xlog_grant_head_wake_all(&log->l_reserve_head);
         xlog_grant_head_wake_all(&log->l_write_head);
 
-        if (!(log->l_iclog->ic_state & XLOG_STATE_IOERROR)) {
-                ASSERT(!logerror);
-                /*
-                 * Force the incore logs to disk before shutting the
-                 * log down completely.
-                 */
-                _xfs_log_force(mp, XFS_LOG_SYNC, NULL);
-
-                spin_lock(&log->l_icloglock);
-                retval = xlog_state_ioerror(log);
-                spin_unlock(&log->l_icloglock);
-        }
-
         /*
          * Wake up everybody waiting on xfs_log_force. Wake the CIL push first
          * as if the log writes were completed. The abort handling in the log