b=22520 set the thread to be uninterrupt before add to waitq

[fs/lustre-release.git] / lustre / lov / lov_lock.c

diff --git a/lustre/lov/lov_lock.c b/lustre/lov/lov_lock.c
index fae9437..cb81e72 100644 (file)
--- a/lustre/lov/lov_lock.c
+++ b/lustre/lov/lov_lock.c
@@ -122,7 +122,7 @@ static void lov_sublock_adopt(const struct lu_env *env, struct lov_lock *lck,
         lck->lls_sub[idx].sub_lock = lsl;
         lck->lls_nr_filled++;
         LASSERT(lck->lls_nr_filled <= lck->lls_nr);
-        list_add_tail(&link->lll_list, &lsl->lss_parents);
+        cfs_list_add_tail(&link->lll_list, &lsl->lss_parents);
         link->lll_idx = idx;
         link->lll_super = lck;
         cl_lock_get(parent);
@@ -205,7 +205,7 @@ static int lov_sublock_lock(const struct lu_env *env,
         int                 result = 0;
         ENTRY;
 
-        LASSERT(list_empty(&closure->clc_list));
+        LASSERT(cfs_list_empty(&closure->clc_list));
 
         sublock = lls->sub_lock;
         child = sublock->lss_cl.cls_lock;
@@ -492,6 +492,52 @@ static void lov_lock_fini(const struct lu_env *env,
 }
 
 /**
+ *
+ * \retval 0 if state-transition can proceed
+ * \retval -ve otherwise.
+ */
+static int lov_lock_enqueue_wait(const struct lu_env *env,
+                                 struct lov_lock *lck,
+                                 struct cl_lock *sublock)
+{
+        struct cl_lock *lock     = lck->lls_cl.cls_lock;
+        struct cl_lock *conflict = sublock->cll_conflict;
+        int result = CLO_REPEAT;
+        ENTRY;
+
+        LASSERT(cl_lock_is_mutexed(lock));
+        LASSERT(cl_lock_is_mutexed(sublock));
+        LASSERT(sublock->cll_state == CLS_QUEUING);
+        LASSERT(conflict != NULL);
+
+        sublock->cll_conflict = NULL;
+        cl_lock_mutex_put(env, lock);
+        cl_lock_mutex_put(env, sublock);
+
+        LASSERT(cl_lock_nr_mutexed(env) == 0);
+
+        cl_lock_mutex_get(env, conflict);
+        cl_lock_cancel(env, conflict);
+        cl_lock_delete(env, conflict);
+        while (conflict->cll_state != CLS_FREEING) {
+                int rc = 0;
+
+                rc = cl_lock_state_wait(env, conflict);
+                if (rc == 0)
+                        continue;
+
+                result = lov_subresult(result, rc);
+                break;
+        }
+        cl_lock_mutex_put(env, conflict);
+        lu_ref_del(&conflict->cll_reference, "cancel-wait", sublock);
+        cl_lock_put(env, conflict);
+
+        cl_lock_mutex_get(env, lock);
+        RETURN(result);
+}
+
+/**
  * Tries to advance a state machine of a given sub-lock toward enqueuing of
  * the top-lock.
  *
@@ -617,13 +663,30 @@ static int lov_lock_enqueue(const struct lu_env *env,
                                                   subenv->lse_io, enqflags,
                                                   i == lck->lls_nr - 1);
                         minstate = min(minstate, sublock->cll_state);
-                        /*
-                         * Don't hold a sub-lock in CLS_CACHED state, see
-                         * description for lov_lock::lls_sub.
-                         */
-                        if (sublock->cll_state > CLS_HELD)
-                                rc = lov_sublock_release(env, lck, i, 1, rc);
-                        lov_sublock_unlock(env, sub, closure, subenv);
+                        if (rc == CLO_WAIT) {
+                                switch (sublock->cll_state) {
+                                case CLS_QUEUING:
+                                        /* take recursive mutex, the lock is
+                                         * released in lov_lock_enqueue_wait.
+                                         */
+                                        cl_lock_mutex_get(env, sublock);
+                                        lov_sublock_unlock(env, sub, closure,
+                                                           subenv);
+                                        rc = lov_lock_enqueue_wait(env, lck,
+                                                                   sublock);
+                                        break;
+                                case CLS_CACHED:
+                                        rc = lov_sublock_release(env, lck, i,
+                                                                 1, rc);
+                                default:
+                                        lov_sublock_unlock(env, sub, closure,
+                                                           subenv);
+                                        break;
+                                }
+                        } else {
+                                LASSERT(sublock->cll_conflict == NULL);
+                                lov_sublock_unlock(env, sub, closure, subenv);
+                        }
                 }
                 result = lov_subresult(result, rc);
                 if (result != 0)
@@ -970,7 +1033,7 @@ static int lov_lock_fits_into(const struct lu_env *env,
                                                      cl2lov(slice->cls_obj),
                                                      lov->lls_sub[0].sub_stripe,
                                                      got, need);
-        } else if (io->ci_type != CIT_TRUNC && io->ci_type != CIT_MISC &&
+        } else if (io->ci_type != CIT_SETATTR && io->ci_type != CIT_MISC &&
                    !cl_io_is_append(io) && need->cld_mode != CLM_PHANTOM)
                 /*
                  * Multi-stripe locks are only suitable for `quick' IO and for
@@ -1004,7 +1067,7 @@ void lov_lock_unlink(const struct lu_env *env,
         LASSERT(cl_lock_is_mutexed(sub->lss_cl.cls_lock));
         ENTRY;
 
-        list_del_init(&link->lll_list);
+        cfs_list_del_init(&link->lll_list);
         LASSERT(lck->lls_sub[link->lll_idx].sub_lock == sub);
         /* yank this sub-lock from parent's array */
         lck->lls_sub[link->lll_idx].sub_lock = NULL;
@@ -1025,7 +1088,7 @@ struct lov_lock_link *lov_lock_link_find(const struct lu_env *env,
         LASSERT(cl_lock_is_mutexed(sub->lss_cl.cls_lock));
         ENTRY;
 
-        list_for_each_entry(scan, &sub->lss_parents, lll_list) {
+        cfs_list_for_each_entry(scan, &sub->lss_parents, lll_list) {
                 if (scan->lll_super == lck)
                         RETURN(scan);
         }
@@ -1148,7 +1211,7 @@ static struct cl_lock_closure *lov_closure_get(const struct lu_env *env,
         struct cl_lock_closure *closure;
 
         closure = &lov_env_info(env)->lti_closure;
-        LASSERT(list_empty(&closure->clc_list));
+        LASSERT(cfs_list_empty(&closure->clc_list));
         cl_lock_closure_init(env, closure, parent, 1);
         return closure;
 }