LU-8578 ldlm: ELC shouldn't wait on lock flush

commit ad87adbff5148a74ac616dbc9bfa02a4e3814034
LU-5727 ldlm: revert the changes for lock canceling policy

but it removes the fix for LU-4300 when lru_resize is disabled.

Introduce ldlm_cancel_aged_no_wait_policy to be used by ELC.

Lustre-change: https://review.whamcloud.com/22286
Lustre-commit: 7ca60f338936465c534c2ac9a0ea467d276a7485

Change-Id: Ic74a6bce4a261dc96c8c0f6d8f7e20315def8c0e
Seagate-bug-id: MRP-3662
Signed-off-by: Andriy Skulysh <andriy.skulysh@seagate.com>
Reviewed-by: Vitaly Fertman <vitaly.fertman@seagate.com>
Reviewed-by: Patrick Farrell <paf@cray.com>
Signed-off-by: Minh Diep <minh.diep@intel.com>
Reviewed-on: https://review.whamcloud.com/29263
Tested-by: Jenkins
Tested-by: Maloo <hpdd-maloo@intel.com>
Reviewed-by: John L. Hammond <john.hammond@intel.com>

diff --git a/lustre/ldlm/ldlm_internal.h b/lustre/ldlm/ldlm_internal.h
index 4f00aca..b7764dc 100644 (file)
--- a/lustre/ldlm/ldlm_internal.h
+++ b/lustre/ldlm/ldlm_internal.h
@@ -103,7 +103,6 @@ enum ldlm_lru_flags {
        LDLM_LRU_FLAG_LRUR      = 0x08, /* Cancel locks from lru resize */
        LDLM_LRU_FLAG_NO_WAIT   = 0x10, /* Cancel locks w/o blocking (neither
                                         * sending nor waiting for any RPCs) */
-       LDLM_LRU_FLAG_LRUR_NO_WAIT = 0x20, /* LRUR + NO_WAIT */
 };
 
 int ldlm_cancel_lru(struct ldlm_namespace *ns, int nr,

diff --git a/lustre/ldlm/ldlm_request.c b/lustre/ldlm/ldlm_request.c
index 7757b8a..8432ade 100644 (file)
--- a/lustre/ldlm/ldlm_request.c
+++ b/lustre/ldlm/ldlm_request.c
@@ -801,8 +801,8 @@ int ldlm_prep_elc_req(struct obd_export *exp, struct ptlrpc_request *req,
                req_capsule_filled_sizes(pill, RCL_CLIENT);
                avail = ldlm_capsule_handles_avail(pill, RCL_CLIENT, canceloff);
 
-               lru_flags = ns_connect_lru_resize(ns) ?
-                       LDLM_LRU_FLAG_LRUR_NO_WAIT : LDLM_LRU_FLAG_AGED;
+               lru_flags = LDLM_LRU_FLAG_NO_WAIT | (ns_connect_lru_resize(ns) ?
+                       LDLM_LRU_FLAG_LRUR : LDLM_LRU_FLAG_AGED);
                to_free = !ns_connect_lru_resize(ns) &&
                        opc == LDLM_ENQUEUE ? 1 : 0;
 
@@ -1593,6 +1593,20 @@ static enum ldlm_policy_res ldlm_cancel_aged_policy(struct ldlm_namespace *ns,
        return LDLM_POLICY_CANCEL_LOCK;
 }
 
+static enum ldlm_policy_res
+ldlm_cancel_aged_no_wait_policy(struct ldlm_namespace *ns,
+                               struct ldlm_lock *lock,
+                               int unused, int added, int count)
+{
+       enum ldlm_policy_res result;
+
+       result = ldlm_cancel_aged_policy(ns, lock, unused, added, count);
+       if (result == LDLM_POLICY_KEEP_LOCK)
+               return result;
+
+       return ldlm_cancel_no_wait_policy(ns, lock, unused, added, count);
+}
+
 /**
  * Callback function for default policy. Makes decision whether to keep \a lock
  * in LRU for current LRU size \a unused, added in current scan \a added and
@@ -1621,23 +1635,28 @@ typedef enum ldlm_policy_res
 static ldlm_cancel_lru_policy_t
 ldlm_cancel_lru_policy(struct ldlm_namespace *ns, enum ldlm_lru_flags lru_flags)
 {
-       if (lru_flags & LDLM_LRU_FLAG_NO_WAIT)
-               return ldlm_cancel_no_wait_policy;
-
        if (ns_connect_lru_resize(ns)) {
                if (lru_flags & LDLM_LRU_FLAG_SHRINK)
                        /* We kill passed number of old locks. */
                        return ldlm_cancel_passed_policy;
-               if (lru_flags & LDLM_LRU_FLAG_LRUR)
-                       return ldlm_cancel_lrur_policy;
+               if (lru_flags & LDLM_LRU_FLAG_LRUR) {
+                       if (lru_flags & LDLM_LRU_FLAG_NO_WAIT)
+                               return ldlm_cancel_lrur_no_wait_policy;
+                       else
+                               return ldlm_cancel_lrur_policy;
+               }
                if (lru_flags & LDLM_LRU_FLAG_PASSED)
                        return ldlm_cancel_passed_policy;
-               else if (lru_flags & LDLM_LRU_FLAG_LRUR_NO_WAIT)
-                       return ldlm_cancel_lrur_no_wait_policy;
        } else {
-               if (lru_flags & LDLM_LRU_FLAG_AGED)
-                       return ldlm_cancel_aged_policy;
+               if (lru_flags & LDLM_LRU_FLAG_AGED) {
+                       if (lru_flags & LDLM_LRU_FLAG_NO_WAIT)
+                               return ldlm_cancel_aged_no_wait_policy;
+                       else
+                               return ldlm_cancel_aged_policy;
+               }
        }
+       if (lru_flags & LDLM_LRU_FLAG_NO_WAIT)
+               return ldlm_cancel_no_wait_policy;
 
        return ldlm_cancel_default_policy;
 }
@@ -1682,8 +1701,7 @@ static int ldlm_prepare_lru_list(struct ldlm_namespace *ns,
        ldlm_cancel_lru_policy_t pf;
        struct ldlm_lock *lock, *next;
        int added = 0, unused, remained;
-       int no_wait = lru_flags & (LDLM_LRU_FLAG_NO_WAIT |
-                                  LDLM_LRU_FLAG_LRUR_NO_WAIT);
+       int no_wait = lru_flags & LDLM_LRU_FLAG_NO_WAIT;
        ENTRY;
 
        spin_lock(&ns->ns_lock);