gfs2: Get rid of delayed withdraws

Now that gfs2_withdraw() is asynchronous, is can be called in any
context and there is no more need for gfs2_withdraw_delayed() or for
turning delayed withdraws into actual withdraws.  Remove the
now-obsolete code.

Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>

diff --git a/fs/gfs2/glock.c b/fs/gfs2/glock.c
index d0f7817e300abca01e1b1cae98bff3a457645378..c15dce8c987be0f93846134c54d5a3458f4e97a0 100644 (file)
--- a/fs/gfs2/glock.c
+++ b/fs/gfs2/glock.c
@@ -756,7 +756,7 @@ __acquires(&gl->gl_lockref.lock)
         * then it's okay to tell dlm to unlock it.
         */
        if (unlikely(sdp->sd_log_error) && !gfs2_withdrawing_or_withdrawn(sdp))
-               gfs2_withdraw_delayed(sdp);
+               gfs2_withdraw(sdp);
        if (glock_blocked_by_withdraw(gl) &&
            (target != LM_ST_UNLOCKED ||
             test_bit(SDF_WITHDRAW_RECOVERY, &sdp->sd_flags))) {

diff --git a/fs/gfs2/glops.c b/fs/gfs2/glops.c
index 0c68ab4432b08aa040b2d5daef433c17c8251dbb..28b22cbfb507478eac921849545e3660f533a8e5 100644 (file)
--- a/fs/gfs2/glops.c
+++ b/fs/gfs2/glops.c
@@ -45,7 +45,7 @@ static void gfs2_ail_error(struct gfs2_glock *gl, const struct buffer_head *bh)
               gl->gl_name.ln_type, gl->gl_name.ln_number,
               gfs2_glock2aspace(gl));
        gfs2_lm(sdp, "AIL error\n");
-       gfs2_withdraw_delayed(sdp);
+       gfs2_withdraw(sdp);
 }
 
 /**
@@ -83,9 +83,6 @@ static void __gfs2_ail_flush(struct gfs2_glock *gl, bool fsync,
        GLOCK_BUG_ON(gl, !fsync && atomic_read(&gl->gl_ail_count));
        spin_unlock(&sdp->sd_ail_lock);
        gfs2_log_unlock(sdp);
-
-       if (gfs2_withdrawing(sdp))
-               gfs2_withdraw(sdp);
 }
 
 
@@ -608,10 +605,10 @@ static int freeze_go_xmote_bh(struct gfs2_glock *gl)
                j_gl->gl_ops->go_inval(j_gl, DIO_METADATA);
 
                error = gfs2_find_jhead(sdp->sd_jdesc, &head);
-               if (gfs2_assert_withdraw_delayed(sdp, !error))
+               if (gfs2_assert_withdraw(sdp, !error))
                        return error;
-               if (gfs2_assert_withdraw_delayed(sdp, head.lh_flags &
-                                                GFS2_LOG_HEAD_UNMOUNT))
+               if (gfs2_assert_withdraw(sdp, head.lh_flags &
+                                        GFS2_LOG_HEAD_UNMOUNT))
                        return -EIO;
                gfs2_log_pointers_init(sdp, &head);
        }

diff --git a/fs/gfs2/incore.h b/fs/gfs2/incore.h
index db0e72adb99961332189746e1c0de1e8f26a42fd..5dfdd1f3c5da6a055d930f29d00ab240bc8b7fa1 100644 (file)
--- a/fs/gfs2/incore.h
+++ b/fs/gfs2/incore.h
@@ -599,7 +599,6 @@ enum {
        SDF_SKIP_DLM_UNLOCK     = 8,
        SDF_FORCE_AIL_FLUSH     = 9,
        SDF_FREEZE_INITIATOR    = 10,
-       SDF_WITHDRAWING         = 11, /* Will withdraw eventually */
        SDF_WITHDRAW_IN_PROG    = 12, /* Withdraw is in progress */
        SDF_REMOTE_WITHDRAW     = 13, /* Performing remote recovery */
        SDF_WITHDRAW_RECOVERY   = 14, /* Wait for journal recovery when we are

diff --git a/fs/gfs2/log.c b/fs/gfs2/log.c
index 115c4ac457e90a5031254cc8207c69cd65f8307c..26a1baa21535032777ab3ab9426bf08c65f12056 100644 (file)
--- a/fs/gfs2/log.c
+++ b/fs/gfs2/log.c
@@ -114,7 +114,7 @@ __acquires(&sdp->sd_ail_lock)
                        }
                        if (!cmpxchg(&sdp->sd_log_error, 0, -EIO)) {
                                gfs2_io_error_bh(sdp, bh);
-                               gfs2_withdraw_delayed(sdp);
+                               gfs2_withdraw(sdp);
                        }
                }
 
@@ -326,7 +326,7 @@ static int gfs2_ail1_empty_one(struct gfs2_sbd *sdp, struct gfs2_trans *tr,
                if (!buffer_uptodate(bh) &&
                    !cmpxchg(&sdp->sd_log_error, 0, -EIO)) {
                        gfs2_io_error_bh(sdp, bh);
-                       gfs2_withdraw_delayed(sdp);
+                       gfs2_withdraw(sdp);
                }
                /*
                 * If we have space for revokes and the bd is no longer on any
@@ -807,9 +807,6 @@ void gfs2_flush_revokes(struct gfs2_sbd *sdp)
        gfs2_log_lock(sdp);
        gfs2_ail1_empty(sdp, max_revokes);
        gfs2_log_unlock(sdp);
-
-       if (gfs2_withdrawing(sdp))
-               gfs2_withdraw(sdp);
 }
 
 /**
@@ -987,9 +984,6 @@ static void empty_ail1_list(struct gfs2_sbd *sdp)
                if (gfs2_withdrawing_or_withdrawn(sdp))
                        break;
        }
-
-       if (gfs2_withdrawing(sdp))
-               gfs2_withdraw(sdp);
 }
 
 /**
@@ -1071,7 +1065,7 @@ void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl, u32 flags)
                        sdp->sd_log_tr = NULL;
                        tr->tr_first = first_log_head;
                        if (unlikely(frozen)) {
-                               if (gfs2_assert_withdraw_delayed(sdp,
+                               if (gfs2_assert_withdraw(sdp,
                                       !tr->tr_num_buf_new && !tr->tr_num_databuf_new))
                                        goto out_withdraw;
                        }
@@ -1096,7 +1090,7 @@ void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl, u32 flags)
                clear_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
 
        if (unlikely(frozen))
-               if (gfs2_assert_withdraw_delayed(sdp, !reserved_revokes))
+               if (gfs2_assert_withdraw(sdp, !reserved_revokes))
                        goto out_withdraw;
 
        gfs2_ordered_write(sdp);
@@ -1151,13 +1145,11 @@ void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl, u32 flags)
                reserved_blocks += (reserved_revokes - sdp->sd_ldptrs) / sdp->sd_inptrs;
 out:
        if (used_blocks != reserved_blocks) {
-               gfs2_assert_withdraw_delayed(sdp, used_blocks < reserved_blocks);
+               gfs2_assert_withdraw(sdp, used_blocks < reserved_blocks);
                gfs2_log_release(sdp, reserved_blocks - used_blocks);
        }
        up_write(&sdp->sd_log_flush_lock);
        gfs2_trans_free(sdp, tr);
-       if (gfs2_withdrawing(sdp))
-               gfs2_withdraw(sdp);
        trace_gfs2_log_flush(sdp, 0, flags);
        return;
 
@@ -1346,9 +1338,6 @@ int gfs2_logd(void *data)
                                t);
        }
 
-       if (gfs2_withdrawing(sdp))
-               gfs2_withdraw(sdp);
-
        return 0;
 }
 

diff --git a/fs/gfs2/lops.c b/fs/gfs2/lops.c
index 233b3aa8edca4fb5f75f72c0cf6546fa431453bc..9f80a37e8b7f91dd4d76f91d54981f5a4cff590f 100644 (file)
--- a/fs/gfs2/lops.c
+++ b/fs/gfs2/lops.c
@@ -209,7 +209,7 @@ static void gfs2_end_log_write(struct bio *bio)
                if (!cmpxchg(&sdp->sd_log_error, 0, err))
                        fs_err(sdp, "Error %d writing to journal, jid=%u\n",
                               err, sdp->sd_jdesc->jd_jid);
-               gfs2_withdraw_delayed(sdp);
+               gfs2_withdraw(sdp);
                /* prevent more writes to the journal */
                clear_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
                wake_up(&sdp->sd_logd_waitq);

diff --git a/fs/gfs2/sys.c b/fs/gfs2/sys.c
index 1213f97419f6450ec1623cc5ca5214e0239c2177..8093a596661ecace60f9bee1ac8cb8fff0e5d98e 100644 (file)
--- a/fs/gfs2/sys.c
+++ b/fs/gfs2/sys.c
@@ -84,7 +84,6 @@ static ssize_t status_show(struct gfs2_sbd *sdp, char *buf)
                     "Force AIL Flush:          %d\n"
                     "FS Freeze Initiator:      %d\n"
                     "FS Frozen:                %d\n"
-                    "Withdrawing:              %d\n"
                     "Withdraw In Prog:         %d\n"
                     "Remote Withdraw:          %d\n"
                     "Withdraw Recovery:        %d\n"
@@ -117,7 +116,6 @@ static ssize_t status_show(struct gfs2_sbd *sdp, char *buf)
                     test_bit(SDF_FORCE_AIL_FLUSH, &f),
                     test_bit(SDF_FREEZE_INITIATOR, &f),
                     test_bit(SDF_FROZEN, &f),
-                    test_bit(SDF_WITHDRAWING, &f),
                     test_bit(SDF_WITHDRAW_IN_PROG, &f),
                     test_bit(SDF_REMOTE_WITHDRAW, &f),
                     test_bit(SDF_WITHDRAW_RECOVERY, &f),

diff --git a/fs/gfs2/util.c b/fs/gfs2/util.c
index c454bea101dec4e2cdc4fcfa417de653cd36f6e0..e15e11f6f16166e6bbef852ed82b007273c00ca5 100644 (file)
--- a/fs/gfs2/util.c
+++ b/fs/gfs2/util.c
@@ -364,8 +364,7 @@ void gfs2_withdraw(struct gfs2_sbd *sdp)
  */
 
 void gfs2_assert_withdraw_i(struct gfs2_sbd *sdp, char *assertion,
-                           const char *function, char *file, unsigned int line,
-                           bool delayed)
+                           const char *function, char *file, unsigned int line)
 {
        if (gfs2_withdrawing_or_withdrawn(sdp))
                return;
@@ -375,17 +374,7 @@ void gfs2_assert_withdraw_i(struct gfs2_sbd *sdp, char *assertion,
               "function = %s, file = %s, line = %u\n",
               assertion, function, file, line);
 
-       /*
-        * If errors=panic was specified on mount, it won't help to delay the
-        * withdraw.
-        */
-       if (sdp->sd_args.ar_errors == GFS2_ERRORS_PANIC)
-               delayed = false;
-
-       if (delayed)
-               gfs2_withdraw_delayed(sdp);
-       else
-               gfs2_withdraw(sdp);
+       gfs2_withdraw(sdp);
        dump_stack();
 }
 

diff --git a/fs/gfs2/util.h b/fs/gfs2/util.h
index f424ef2523c4332d6ebead7772a1d1c6373dddd7..51347a467b89737d6ed738d1a47061d80c8a2656 100644 (file)
--- a/fs/gfs2/util.h
+++ b/fs/gfs2/util.h
@@ -37,24 +37,14 @@ do { \
 
 
 void gfs2_assert_withdraw_i(struct gfs2_sbd *sdp, char *assertion,
-                           const char *function, char *file, unsigned int line,
-                           bool delayed);
+                           const char *function, char *file, unsigned int line);
 
 #define gfs2_assert_withdraw(sdp, assertion) \
        ({ \
                bool _bool = (assertion); \
                if (unlikely(!_bool)) \
                        gfs2_assert_withdraw_i((sdp), #assertion, \
-                                       __func__, __FILE__, __LINE__, false); \
-               !_bool; \
-       })
-
-#define gfs2_assert_withdraw_delayed(sdp, assertion) \
-       ({ \
-               bool _bool = (assertion); \
-               if (unlikely(!_bool)) \
-                       gfs2_assert_withdraw_i((sdp), #assertion, \
-                                       __func__, __FILE__, __LINE__, true); \
+                                       __func__, __FILE__, __LINE__); \
                !_bool; \
        })
 
@@ -192,15 +182,6 @@ static inline unsigned int gfs2_tune_get_i(struct gfs2_tune *gt,
        return x;
 }
 
-/**
- * gfs2_withdraw_delayed - withdraw as soon as possible without deadlocks
- * @sdp: the superblock
- */
-static inline void gfs2_withdraw_delayed(struct gfs2_sbd *sdp)
-{
-       set_bit(SDF_WITHDRAWING, &sdp->sd_flags);
-}
-
 /**
  * gfs2_withdrawing_or_withdrawn - test whether the file system is withdrawing
  *                                 or withdrawn
@@ -208,18 +189,7 @@ static inline void gfs2_withdraw_delayed(struct gfs2_sbd *sdp)
  */
 static inline bool gfs2_withdrawing_or_withdrawn(struct gfs2_sbd *sdp)
 {
-       return unlikely(test_bit(SDF_WITHDRAWN, &sdp->sd_flags) ||
-                       test_bit(SDF_WITHDRAWING, &sdp->sd_flags));
-}
-
-/**
- * gfs2_withdrawing - check if a withdraw is pending
- * @sdp: the superblock
- */
-static inline bool gfs2_withdrawing(struct gfs2_sbd *sdp)
-{
-       return unlikely(test_bit(SDF_WITHDRAWING, &sdp->sd_flags) &&
-                       !test_bit(SDF_WITHDRAWN, &sdp->sd_flags));
+       return unlikely(test_bit(SDF_WITHDRAWN, &sdp->sd_flags));
 }
 
 static inline bool gfs2_withdraw_in_prog(struct gfs2_sbd *sdp)