From d199b178ed694dfafa3082604a440d08166067ce Mon Sep 17 00:00:00 2001 From: Mr NeilBrown Date: Tue, 6 Feb 2024 09:46:49 +1100 Subject: [PATCH] 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 Change-Id: Iec92a41c174e4884852ebf8fbb2cd50d4e165035 Reviewed-on: https://review.whamcloud.com/c/fs/lustre-release/+/53931 Tested-by: jenkins Tested-by: Maloo Reviewed-by: Oleg Drokin Reviewed-by: Andreas Dilger Reviewed-by: Yang Sheng Reviewed-by: James Simmons --- lustre/include/lustre_dlm.h | 43 ++++++++++++++++++++++++++----------------- lustre/ldlm/ldlm_flock.c | 16 ++++++++-------- lustre/ldlm/ldlm_lock.c | 16 +++++++++++++--- 3 files changed, 47 insertions(+), 28 deletions(-) diff --git a/lustre/include/lustre_dlm.h b/lustre/include/lustre_dlm.h index ca1b5b6..97b1979 100644 --- 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 --- 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 --- 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); -- 1.8.3.1