LU-11085 ldlm: save space in struct ldlm_lock

Moving the 'interval' handle into ldlm_lock has made the structure
bigger.  Compensate for this by shared space for fields only needs for
specific lock types.

i.e.  some fields are only needed for EXTENT locks, some for FLOCK
locks, some for PLAIN and IBITS which use "skiplists".

One x86_64 the reduces the size of ldlm_lock to what is was before the
previous patch.  A future patch will reduce it even more.

As extent and flock both used the interval tree node, they now have
different instances.  So the names in flock are changed.  Both of
these will disappear in future patches.

Signed-off-by: Mr NeilBrown <neilb@suse.de>
Change-Id: Iec92a41c174e4884852ebf8fbb2cd50d4e165035
Reviewed-on: https://review.whamcloud.com/c/fs/lustre-release/+/53931
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>
Reviewed-by: Yang Sheng <ys@whamcloud.com>
Reviewed-by: James Simmons <jsimmons@infradead.org>

diff --git a/lustre/include/lustre_dlm.h b/lustre/include/lustre_dlm.h
index ca1b5b6..97b1979 100644 (file)
--- a/lustre/include/lustre_dlm.h
+++ b/lustre/include/lustre_dlm.h
@@ -812,8 +812,32 @@ struct ldlm_lock {
         * Internal structures per lock type..
         */
        union {
-               struct interval_node    l_tree_node;
-               struct ldlm_ibits_node  *l_ibits_node;
+               /* LDLM_EXTENT locks only */
+               struct {
+                       /* Originally requested extent for the extent lock. */
+                       struct ldlm_extent      l_req_extent;
+                       struct interval_node    l_tree_node;
+               };
+               /* LDLM_PLAIN and LDLM_IBITS locks */
+               struct {
+                       /**
+                        * Protected by lr_lock, linkages to "skip lists".
+                        * For more explanations of skip lists see ldlm/ldlm_inodebits.c
+                        */
+                       struct list_head        l_sl_mode;
+                       struct list_head        l_sl_policy;
+
+                       struct ldlm_ibits_node  *l_ibits_node;
+               };
+               /* LDLM_FLOCK locks */
+               struct {
+                       struct interval_node    l_tree_node_flock;
+                       /**
+                        * Per export hash of flock locks.
+                        * Protected by per-bucket exp->exp_flock_hash locks.
+                        */
+                       struct hlist_node       l_exp_flock_hash;
+               };
        };
        /**
         * Per export hash of locks.
@@ -821,11 +845,6 @@ struct ldlm_lock {
         */
        struct hlist_node       l_exp_hash;
        /**
-        * Per export hash of flock locks.
-        * Protected by per-bucket exp->exp_flock_hash locks.
-        */
-       struct hlist_node       l_exp_flock_hash;
-       /**
         * Requested mode.
         * Protected by lr_lock.
         */
@@ -903,9 +922,6 @@ struct ldlm_lock {
         */
        ktime_t                 l_last_used;
 
-       /** Originally requested extent for the extent lock. */
-       struct ldlm_extent      l_req_extent;
-
        /*
         * Client-side-only members.
         */
@@ -988,13 +1004,6 @@ struct ldlm_lock {
         */
        struct ldlm_lock        *l_blocking_lock;
 
-       /**
-        * Protected by lr_lock, linkages to "skip lists".
-        * For more explanations of skip lists see ldlm/ldlm_inodebits.c
-        */
-       struct list_head        l_sl_mode;
-       struct list_head        l_sl_policy;
-
        /** Reference tracking structure to debug leaked locks. */
        struct lu_ref           l_reference;
 #if LUSTRE_TRACKS_LOCK_EXP_REFS

diff --git a/lustre/ldlm/ldlm_flock.c b/lustre/ldlm/ldlm_flock.c
index e4568cf..659dd4a 100644 (file)
--- a/lustre/ldlm/ldlm_flock.c
+++ b/lustre/ldlm/ldlm_flock.c
@@ -122,10 +122,10 @@ void ldlm_flock_unlink_lock(struct ldlm_lock *lock)
        struct ldlm_resource *res = lock->l_resource;
        struct interval_node **root = &res->lr_flock_node.lfn_root;
 
-       if (!interval_is_intree(&lock->l_tree_node)) /* duplicate unlink */
+       if (!interval_is_intree(&lock->l_tree_node_flock)) /* duplicate unlink */
                return;
 
-       interval_erase(&lock->l_tree_node, root);
+       interval_erase(&lock->l_tree_node_flock, root);
 }
 
 static inline void
@@ -286,13 +286,13 @@ static void ldlm_flock_add_lock(struct ldlm_resource *res,
 
        LASSERT(ldlm_is_granted(lock));
 
-       LASSERT(!interval_is_intree(&lock->l_tree_node));
+       LASSERT(!interval_is_intree(&lock->l_tree_node_flock));
 
-       rc = interval_set(&lock->l_tree_node, extent->start, extent->end);
+       rc = interval_set(&lock->l_tree_node_flock, extent->start, extent->end);
        LASSERT(!rc);
 
        root = &res->lr_flock_node.lfn_root;
-       interval_insert(&lock->l_tree_node, root);
+       interval_insert(&lock->l_tree_node_flock, root);
 
        /* Add the locks into list */
        ldlm_resource_add_lock(res, head, lock);
@@ -305,9 +305,9 @@ ldlm_flock_range_update(struct ldlm_lock *lock, struct ldlm_lock *req)
        struct interval_node **root = &res->lr_flock_node.lfn_root;
        struct ldlm_extent *extent = &lock->l_policy_data.l_extent;
 
-       interval_erase(&lock->l_tree_node, root);
-       interval_set(&lock->l_tree_node, extent->start, extent->end);
-       interval_insert(&lock->l_tree_node, root);
+       interval_erase(&lock->l_tree_node_flock, root);
+       interval_set(&lock->l_tree_node_flock, extent->start, extent->end);
+       interval_insert(&lock->l_tree_node_flock, root);
 
        EXIT;
 }

diff --git a/lustre/ldlm/ldlm_lock.c b/lustre/ldlm/ldlm_lock.c
index 1a30ab8..760a7b8 100644 (file)
--- a/lustre/ldlm/ldlm_lock.c
+++ b/lustre/ldlm/ldlm_lock.c
@@ -473,10 +473,20 @@ static struct ldlm_lock *ldlm_lock_new(struct ldlm_resource *resource)
        INIT_LIST_HEAD(&lock->l_rk_ast);
        init_waitqueue_head(&lock->l_waitq);
        lock->l_blocking_lock = NULL;
-       INIT_LIST_HEAD(&lock->l_sl_mode);
-       INIT_LIST_HEAD(&lock->l_sl_policy);
+       switch (resource->lr_type) {
+       case LDLM_IBITS:
+       case LDLM_PLAIN:
+               INIT_LIST_HEAD(&lock->l_sl_mode);
+               INIT_LIST_HEAD(&lock->l_sl_policy);
+               break;
+       case LDLM_FLOCK:
+               INIT_HLIST_NODE(&lock->l_exp_flock_hash);
+               break;
+       case LDLM_EXTENT:
+       case LDLM_MAX_TYPE:
+               break;
+       }
        INIT_HLIST_NODE(&lock->l_exp_hash);
-       INIT_HLIST_NODE(&lock->l_exp_flock_hash);
 
        lprocfs_counter_incr(ldlm_res_to_ns(resource)->ns_stats,
                             LDLM_NSS_LOCKS);