staging/lustre/lov: to not hold sub locks at initialization

Otherwise, it will cause deadlock because it essentially holds
some sub locks and then to request others in an arbitrary order.

Signed-off-by: Jinshan Xiong <jinshan.xiong@intel.com>
Reviewed-on: http://review.whamcloud.com/9152
Reviewed-by: Lai Siyao <lai.siyao@intel.com>
Reviewed-by: Bobi Jam <bobijam@gmail.com>
Signed-off-by: Oleg Drokin <oleg.drokin@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/staging/lustre/lustre/lov/lov_lock.c b/drivers/staging/lustre/lustre/lov/lov_lock.c
index 0bbe141bf4e4f2d7eedb4a1f88b01151c31d3e3f..08ac3745f0dae3c57c2490ca0cf95f9ccb507f82 100644 (file)
--- a/drivers/staging/lustre/lustre/lov/lov_lock.c
+++ b/drivers/staging/lustre/lustre/lov/lov_lock.c
@@ -346,41 +346,7 @@ static int lov_lock_sub_init(const struct lu_env *env,
                }
        }
        LASSERT(nr == lck->lls_nr);
-       /*
-        * Then, create sub-locks. Once at least one sub-lock was created,
-        * top-lock can be reached by other threads.
-        */
-       for (i = 0; i < lck->lls_nr; ++i) {
-               struct cl_lock       *sublock;
-               struct lov_lock_link *link;
 
-               if (lck->lls_sub[i].sub_lock == NULL) {
-                       sublock = lov_sublock_alloc(env, io, lck, i, &link);
-                       if (IS_ERR(sublock)) {
-                               result = PTR_ERR(sublock);
-                               break;
-                       }
-                       cl_lock_get_trust(sublock);
-                       cl_lock_mutex_get(env, sublock);
-                       cl_lock_mutex_get(env, parent);
-                       /*
-                        * recheck under mutex that sub-lock wasn't created
-                        * concurrently, and that top-lock is still alive.
-                        */
-                       if (lck->lls_sub[i].sub_lock == NULL &&
-                           parent->cll_state < CLS_FREEING) {
-                               lov_sublock_adopt(env, lck, sublock, i, link);
-                               cl_lock_mutex_put(env, parent);
-                       } else {
-                               OBD_SLAB_FREE_PTR(link, lov_lock_link_kmem);
-                               cl_lock_mutex_put(env, parent);
-                               cl_lock_unhold(env, sublock,
-                                              "lov-parent", parent);
-                       }
-                       cl_lock_mutex_put(env, sublock);
-                       cl_lock_put(env, sublock);
-               }
-       }
        /*
         * Some sub-locks can be missing at this point. This is not a problem,
         * because enqueue will create them anyway. Main duty of this function
@@ -533,7 +499,7 @@ static int lov_lock_enqueue_one(const struct lu_env *env, struct lov_lock *lck,
 static int lov_sublock_fill(const struct lu_env *env, struct cl_lock *parent,
                            struct cl_io *io, struct lov_lock *lck, int idx)
 {
-       struct lov_lock_link *link;
+       struct lov_lock_link *link = NULL;
        struct cl_lock       *sublock;
        int                result;