LU-160 Reduce OST size requirement for test 155

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

diff --git a/lustre/lov/lov_lock.c b/lustre/lov/lov_lock.c
index 563b625..d633309 100644 (file)
--- a/lustre/lov/lov_lock.c
+++ b/lustre/lov/lov_lock.c
@@ -26,7 +26,7 @@
  * GPL HEADER END
  */
 /*
- * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  */
 /*
@@ -321,7 +321,7 @@ static int lov_lock_sub_init(const struct lu_env *env,
                         nr++;
         }
         LASSERT(nr > 0);
-        OBD_ALLOC(lck->lls_sub, nr * sizeof lck->lls_sub[0]);
+        OBD_ALLOC_LARGE(lck->lls_sub, nr * sizeof lck->lls_sub[0]);
         if (lck->lls_sub == NULL)
                 RETURN(-ENOMEM);
 
@@ -485,56 +485,27 @@ static void lov_lock_fini(const struct lu_env *env,
                          * a reference on its parent.
                          */
                         LASSERT(lck->lls_sub[i].sub_lock == NULL);
-                OBD_FREE(lck->lls_sub, lck->lls_nr * sizeof lck->lls_sub[0]);
+                OBD_FREE_LARGE(lck->lls_sub,
+                               lck->lls_nr * sizeof lck->lls_sub[0]);
         }
         OBD_SLAB_FREE_PTR(lck, lov_lock_kmem);
         EXIT;
 }
 
-/**
- *
- * \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;
+        struct cl_lock *lock = lck->lls_cl.cls_lock;
+        int             result;
         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);
-
+        result = cl_lock_enqueue_wait(env, sublock, 0);
         cl_lock_mutex_get(env, lock);
-        RETURN(result);
+        RETURN(result ?: CLO_REPEAT);
 }
 
 /**
@@ -1033,7 +1004,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
@@ -1050,7 +1021,7 @@ static int lov_lock_fits_into(const struct lu_env *env,
                  * match against original lock extent.
                  */
                 result = cl_lock_ext_match(&lov->lls_orig, need);
-        CDEBUG(D_DLMTRACE, DDESCR"/"DDESCR" %i %i/%i: %i\n",
+        CDEBUG(D_DLMTRACE, DDESCR"/"DDESCR" %d %d/%d: %d\n",
                PDESCR(&lov->lls_orig), PDESCR(&lov->lls_sub[0].sub_got),
                lov->lls_sub[0].sub_stripe, lov->lls_nr, lov_r0(obj)->lo_nr,
                result);
@@ -1114,44 +1085,40 @@ static void lov_lock_delete(const struct lu_env *env,
 {
         struct lov_lock        *lck     = cl2lov_lock(slice);
         struct cl_lock_closure *closure = lov_closure_get(env, slice->cls_lock);
-        int i;
+        struct lov_lock_link   *link;
+        int                     rc;
+        int                     i;
 
         LASSERT(slice->cls_lock->cll_state == CLS_FREEING);
         ENTRY;
 
         for (i = 0; i < lck->lls_nr; ++i) {
-                struct lov_lock_sub *lls;
-                struct lovsub_lock  *lsl;
-                struct cl_lock      *sublock;
-                int rc;
+                struct lov_lock_sub *lls = &lck->lls_sub[i];
+                struct lovsub_lock  *lsl = lls->sub_lock;
 
-                lls = &lck->lls_sub[i];
-                lsl = lls->sub_lock;
-                if (lsl == NULL)
+                if (lsl == NULL) /* already removed */
                         continue;
 
-                sublock = lsl->lss_cl.cls_lock;
                 rc = lov_sublock_lock(env, lck, lls, closure, NULL);
-                if (rc == 0) {
-                        if (lls->sub_flags & LSF_HELD)
-                                lov_sublock_release(env, lck, i, 1, 0);
-                        if (sublock->cll_state < CLS_FREEING) {
-                                struct lov_lock_link *link;
-
-                                link = lov_lock_link_find(env, lck, lsl);
-                                LASSERT(link != NULL);
-                                lov_lock_unlink(env, link, lsl);
-                                LASSERT(lck->lls_sub[i].sub_lock == NULL);
-                        }
-                        lov_sublock_unlock(env, lsl, closure, NULL);
-                } else if (rc == CLO_REPEAT) {
-                        --i; /* repeat with this lock */
-                } else {
-                        CL_LOCK_DEBUG(D_ERROR, env, sublock,
-                                      "Cannot get sub-lock for delete: %i\n",
-                                      rc);
+                if (rc == CLO_REPEAT) {
+                        --i;
+                        continue;
                 }
+
+                LASSERT(rc == 0);
+                LASSERT(lsl->lss_cl.cls_lock->cll_state < CLS_FREEING);
+
+                if (lls->sub_flags & LSF_HELD)
+                        lov_sublock_release(env, lck, i, 1, 0);
+
+                link = lov_lock_link_find(env, lck, lsl);
+                LASSERT(link != NULL);
+                lov_lock_unlink(env, link, lsl);
+                LASSERT(lck->lls_sub[i].sub_lock == NULL);
+
+                lov_sublock_unlock(env, lsl, closure, NULL);
         }
+
         cl_lock_closure_fini(closure);
         EXIT;
 }