- Modify ldlm_completion_ast to wake up when locks are cancelled as well as

  granted
- Wake sleepers in ldlm_lock_destroy

diff --git a/lustre/ldlm/ldlm_lock.c b/lustre/ldlm/ldlm_lock.c
index a17a27a..bb3119b 100644 (file)
--- a/lustre/ldlm/ldlm_lock.c
+++ b/lustre/ldlm/ldlm_lock.c
@@ -210,6 +210,10 @@ void ldlm_lock_destroy(struct ldlm_lock *lock)
         lock->l_export = NULL;
         lock->l_flags |= LDLM_FL_DESTROYED;
 
+        /* Wake anyone waiting for this lock */
+        if (lock->l_completion_ast)
+                lock->l_completion_ast(lock, 0);
+
         l_unlock(&lock->l_resource->lr_namespace->ns_lock);
         LDLM_LOCK_PUT(lock);
         EXIT;

diff --git a/lustre/ldlm/ldlm_request.c b/lustre/ldlm/ldlm_request.c
index 7684162..cf820ea 100644 (file)
--- a/lustre/ldlm/ldlm_request.c
+++ b/lustre/ldlm/ldlm_request.c
@@ -75,34 +75,41 @@ int ldlm_completion_ast(struct ldlm_lock *lock, int flags)
         int rc = 0;
         ENTRY;
 
-        if (flags & (LDLM_FL_BLOCK_WAIT | LDLM_FL_BLOCK_GRANTED |
-                     LDLM_FL_BLOCK_CONV)) {
-                /* Go to sleep until the lock is granted. */
-                /* FIXME: or cancelled. */
-                LDLM_DEBUG(lock, "client-side enqueue returned a blocked lock,"
-                           " sleeping");
-                ldlm_lock_dump(lock);
-                ldlm_reprocess_all(lock->l_resource);
-                rc = l_wait_event(lock->l_waitq,
-                                  (lock->l_req_mode == lock->l_granted_mode),
-                                  &lwi);
-                if (rc) {
-                        LDLM_DEBUG(lock,
-                                   "client-side enqueue waking up: failed (%d)",
-                                   rc);
-                } else {
-                        LDLM_DEBUG(lock,
-                                   "client-side enqueue waking up: granted");
-                }
-        } else if (flags == LDLM_FL_WAIT_NOREPROC) {
-                rc = l_wait_event(lock->l_waitq,
-                                  (lock->l_req_mode == lock->l_granted_mode),
-                                  &lwi);
-        } else if (flags == 0) {
+        if (flags == 0) {
                 wake_up(&lock->l_waitq);
+                RETURN(0);
+        }
+
+        if (flags == LDLM_FL_WAIT_NOREPROC)
+                goto noreproc;
+
+        LASSERT(flags & (LDLM_FL_BLOCK_WAIT | LDLM_FL_BLOCK_GRANTED |
+                         LDLM_FL_BLOCK_CONV));
+
+        LDLM_DEBUG(lock, "client-side enqueue returned a blocked lock, "
+                   "sleeping");
+        ldlm_lock_dump(lock);
+        ldlm_reprocess_all(lock->l_resource);
+
+ noreproc:
+        /* Go to sleep until the lock is granted or cancelled. */
+        rc = l_wait_event(lock->l_waitq,
+                          ((lock->l_req_mode == lock->l_granted_mode) ||
+                           (lock->l_flags & LDLM_FL_DESTROYED)), &lwi);
+
+        if (lock->l_flags & LDLM_FL_DESTROYED) {
+                LDLM_DEBUG(lock, "client-side enqueue waking up: destroyed");
+                RETURN(-EIO);
         }
 
-        RETURN(rc);
+        if (rc) {
+                LDLM_DEBUG(lock, "client-side enqueue waking up: failed (%d)",
+                           rc);
+                RETURN(rc);
+        }
+
+        LDLM_DEBUG(lock, "client-side enqueue waking up: granted");
+        RETURN(0);
 }
 
 static int ldlm_cli_enqueue_local(struct ldlm_namespace *ns,