LU-4621 ofd: create same count of objects

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

diff --git a/lustre/lov/lovsub_lock.c b/lustre/lov/lovsub_lock.c
index 6963e59..7916d20 100644 (file)
--- a/lustre/lov/lovsub_lock.c
+++ b/lustre/lov/lovsub_lock.c
@@ -59,33 +59,33 @@ static void lovsub_lock_fini(const struct lu_env *env,
 
         ENTRY;
         lsl = cl2lovsub_lock(slice);
-        LASSERT(cfs_list_empty(&lsl->lss_parents));
+       LASSERT(list_empty(&lsl->lss_parents));
         OBD_SLAB_FREE_PTR(lsl, lovsub_lock_kmem);
         EXIT;
 }
 
 static void lovsub_parent_lock(const struct lu_env *env, struct lov_lock *lov)
 {
-        struct cl_lock *parent;
-
-        ENTRY;
-        parent = lov->lls_cl.cls_lock;
-        cl_lock_get(parent);
-        lu_ref_add(&parent->cll_reference, "lovsub-parent", cfs_current());
-        cl_lock_mutex_get(env, parent);
-        EXIT;
+       struct cl_lock *parent;
+
+       ENTRY;
+       parent = lov->lls_cl.cls_lock;
+       cl_lock_get(parent);
+       lu_ref_add(&parent->cll_reference, "lovsub-parent", current);
+       cl_lock_mutex_get(env, parent);
+       EXIT;
 }
 
 static void lovsub_parent_unlock(const struct lu_env *env, struct lov_lock *lov)
 {
-        struct cl_lock *parent;
-
-        ENTRY;
-        parent = lov->lls_cl.cls_lock;
-        cl_lock_mutex_put(env, lov->lls_cl.cls_lock);
-        lu_ref_del(&parent->cll_reference, "lovsub-parent", cfs_current());
-        cl_lock_put(env, parent);
-        EXIT;
+       struct cl_lock *parent;
+
+       ENTRY;
+       parent = lov->lls_cl.cls_lock;
+       cl_lock_mutex_put(env, lov->lls_cl.cls_lock);
+       lu_ref_del(&parent->cll_reference, "lovsub-parent", current);
+       cl_lock_put(env, parent);
+       EXIT;
 }
 
 /**
@@ -103,7 +103,7 @@ static void lovsub_lock_state(const struct lu_env *env,
         LASSERT(cl_lock_is_mutexed(slice->cls_lock));
         ENTRY;
 
-        cfs_list_for_each_entry(scan, &sub->lss_parents, lll_list) {
+       list_for_each_entry(scan, &sub->lss_parents, lll_list) {
                 struct lov_lock *lov    = scan->lll_super;
                 struct cl_lock  *parent = lov->lls_cl.cls_lock;
 
@@ -131,7 +131,7 @@ static unsigned long lovsub_lock_weigh(const struct lu_env *env,
 
         LASSERT(cl_lock_is_mutexed(slice->cls_lock));
 
-        if (!cfs_list_empty(&lock->lss_parents)) {
+       if (!list_empty(&lock->lss_parents)) {
                 /*
                  * It is not clear whether all parents have to be asked and
                  * their estimations summed, or it is enough to ask one. For
@@ -220,7 +220,14 @@ int lov_sublock_modify(const struct lu_env *env, struct lov_lock *lov,
         pd->cld_mode = parent_descr->cld_mode;
         pd->cld_gid  = parent_descr->cld_gid;
         lovsub_lock_descr_map(d, subobj->lso_super, subobj->lso_index, pd);
-        lov->lls_sub[idx].sub_got = *d;
+
+       /* LU-3027: only update extent of lock, plus the change in
+        * lovsub_lock_delete() that lock extent is modified after a sublock
+        * is canceled, we can make sure that the lock extent won't be updated
+        * any more. Therefore, lov_lock_fits_into() will always find feasible
+        * locks */
+        lov->lls_sub[idx].sub_got.cld_start = d->cld_start;
+        lov->lls_sub[idx].sub_got.cld_end = d->cld_end;
         /*
          * Notify top-lock about modification, if lock description changes
          * materially.
@@ -245,7 +252,7 @@ static int lovsub_lock_modify(const struct lu_env *env,
 
         LASSERT(cl_lock_mode_match(d->cld_mode,
                                    s->cls_lock->cll_descr.cld_mode));
-        cfs_list_for_each_entry(scan, &lock->lss_parents, lll_list) {
+       list_for_each_entry(scan, &lock->lss_parents, lll_list) {
                 int rc;
 
                 lov = scan->lll_super;
@@ -272,7 +279,7 @@ static int lovsub_lock_closure(const struct lu_env *env,
         sub    = cl2lovsub_lock(slice);
         result = 0;
 
-        cfs_list_for_each_entry(scan, &sub->lss_parents, lll_list) {
+       list_for_each_entry(scan, &sub->lss_parents, lll_list) {
                 parent = scan->lll_super->lls_cl.cls_lock;
                 result = cl_lock_closure_build(env, parent, closure);
                 if (result != 0)
@@ -297,6 +304,7 @@ static int lovsub_lock_delete_one(const struct lu_env *env,
                 RETURN(0);
 
         result = 0;
+       lov->lls_ever_canceled = 1;
         switch (parent->cll_state) {
        case CLS_ENQUEUED:
                /* See LU-1355 for the case that a glimpse lock is
@@ -416,15 +424,12 @@ static void lovsub_lock_delete(const struct lu_env *env,
                 struct lov_lock      *lov;
                 struct lov_lock_link *scan;
                 struct lov_lock_link *temp;
-                struct lov_lock_sub  *subdata;
 
                 restart = 0;
-                cfs_list_for_each_entry_safe(scan, temp,
+               list_for_each_entry_safe(scan, temp,
                                              &sub->lss_parents, lll_list) {
                         lov     = scan->lll_super;
-                        subdata = &lov->lls_sub[scan->lll_idx];
                         lovsub_parent_lock(env, lov);
-                        subdata->sub_got = subdata->sub_descr;
                         lov_lock_unlink(env, scan, sub);
                         restart = lovsub_lock_delete_one(env, child, lov);
                         lovsub_parent_unlock(env, lov);
@@ -445,7 +450,7 @@ static int lovsub_lock_print(const struct lu_env *env, void *cookie,
         struct lov_lock      *lov;
         struct lov_lock_link *scan;
 
-        cfs_list_for_each_entry(scan, &sub->lss_parents, lll_list) {
+       list_for_each_entry(scan, &sub->lss_parents, lll_list) {
                 lov = scan->lll_super;
                 (*p)(env, cookie, "[%d %p ", scan->lll_idx, lov);
                 if (lov != NULL)
@@ -467,20 +472,20 @@ static const struct cl_lock_operations lovsub_lock_ops = {
 };
 
 int lovsub_lock_init(const struct lu_env *env, struct cl_object *obj,
-                     struct cl_lock *lock, const struct cl_io *io)
+                    struct cl_lock *lock, const struct cl_io *io)
 {
-        struct lovsub_lock *lsk;
-        int result;
-
-        ENTRY;
-       OBD_SLAB_ALLOC_PTR_GFP(lsk, lovsub_lock_kmem, __GFP_IO);
-        if (lsk != NULL) {
-                CFS_INIT_LIST_HEAD(&lsk->lss_parents);
-                cl_lock_slice_add(lock, &lsk->lss_cl, obj, &lovsub_lock_ops);
-                result = 0;
-        } else
-                result = -ENOMEM;
-        RETURN(result);
+       struct lovsub_lock *lsk;
+       int result;
+
+       ENTRY;
+       OBD_SLAB_ALLOC_PTR_GFP(lsk, lovsub_lock_kmem, GFP_NOFS);
+       if (lsk != NULL) {
+               INIT_LIST_HEAD(&lsk->lss_parents);
+               cl_lock_slice_add(lock, &lsk->lss_cl, obj, &lovsub_lock_ops);
+               result = 0;
+       } else
+               result = -ENOMEM;
+       RETURN(result);
 }
 
 /** @} lov */