locking/lockdep: Add support for dynamic keys
Subsystems (5)
v7 cover locking/lockdep: Add support for dynamic keys
Hi Peter and Ingo,
A known shortcoming of the current lockdep implementation is that it requires lock keys to be allocated statically. This forces certain unrelated synchronization objects to share keys and this key sharing can cause false positive deadlock reports. This patch series adds support for dynamic keys in the lockdep code and eliminates a class of false positive reports from the workqueue implementation.
Please consider these patches for kernel v5.1.
Thanks,
Bart.
The changes compared to v6 are:
- For delayed freeing, adopted Peter's approach since that approach does not require to sleep in the context from which data structures are freed.
- Instead of delayed freeing list_entries[] elements, free these immediately.
- Added two patches that fix a false positive lockdep complaint in the block layer.
- Split several patches to make these easier to read.
The changes compared to v5 are:
- Modified zap_class() such that it doesn't try to free a list entry that is already being freed.
- Added a patch that fixes an existing bug in add_chain_cache().
- Improved the code that reports the size needed for lockdep data structures further.
- Rebased and retested this patch series on top of kernel v5.0-rc1.
The changes compared to v4 are:
- Introduced the function lockdep_set_selftest_task() to fix a build failure for CONFIG_LOCKDEP=n.
- Fixed a use-after-free issue in is_dynamic_key() by adding the following code in that function: if (!debug_locks) return true;
- Changed if (WARN_ON_ONCE(!pf)) into if (!pf) to avoid that the new lockdep implementation triggers more kernel warnings than the current implementation. This keeps the build happy when doing regression tests.
- Added a synchronize_rcu() call at the end of lockdep_unregister_key() to avoid a use-after-free.
The changes compared to v3 are:
- Rework the code that frees objects that are no longer used such that it is now guaranteed that a grace period elapses between last use and freeing.
- The lockdep self tests pass again.
- Avoid that the patch that removes all matching lock order entries can cause list corruption. Note: the change in this patch to realize that is removed again by a later patch. In other words, this change is only necessary to make the series bisectable.
- Rebased this patch series on top of the tip/locking/core branch.
The changes compared to v2 are:
- Made sure that all schedule_free_zapped_classes() calls are protected with the graph lock.
- When removing a lock class, only recalculate lock chains that have been modified.
- Combine a list_del() and list_add_tail() call into a list_move_tail() call in register_lock_class().
- Use an RCU read lock instead of the graph lock inside is_dynamic_key().
The changes compared to v1 are:
- Addressed Peter's review comments: remove the list_head that I had added to struct lock_list again, replaced all_list_entries and free_list_entries by two bitmaps, use call_rcu() to free lockdep objects, add a BUILD_BUG_ON() that compares the size of struct lock_class_key and raw_spin_lock_t.
- Addressed the "unknown symbol" errors reported by the build bot by adding a few #ifdef / #endif directives. Addressed the 32-bit warnings by using %d instead of %ld for array indices and by casting the array indices to unsigned int.
- Removed several WARN_ON_ONCE(!class->hash_entry.pprev) statements since these duplicate the code in check_data_structures().
- Left out the patch that causes lockdep to complain if no name has been assigned to a lock object. That patch namely causes the build bot to complain about certain lock objects but I have not yet had the time to figure out the identity of these lock objects.
Bart Van Assche (23):
locking/lockdep: Fix two 32-bit compiler warnings locking/lockdep: Fix reported required memory size (1/2) locking/lockdep: Fix reported required memory size (2/2) locking/lockdep: Avoid that add_chain_cache() adds an invalid chain to
the cache
locking/lockdep: Reorder struct lock_class members locking/lockdep: Make zap_class() remove all matching lock order
entries
locking/lockdep: Initialize the locks_before and locks_after lists
earlier
locking/lockdep: Split lockdep_free_key_range() and
lockdep_reset_lock()
locking/lockdep: Make it easy to detect whether or not inside a
selftest
locking/lockdep: Update two outdated comments locking/lockdep: Free lock classes that are no longer in use locking/lockdep: Reuse list entries that are no longer in use locking/lockdep: Introduce lockdep_next_lockchain() and
lock_chain_count()
locking/lockdep: Fix a comment in add_chain_cache() locking/lockdep: Reuse lock chains that have been freed locking/lockdep: Check data structure consistency locking/lockdep: Verify whether lock objects are small enough to be
used as class keys
locking/lockdep: Add support for dynamic keys kernel/workqueue: Use dynamic lockdep keys for workqueues locking/spinlock: Introduce spin_lock_init_key()
block: Avoid that flushing triggers a lockdep complaint lockdep tests: Fix run_tests.sh
lockdep tests: Test dynamic key registration
block/blk-flush.c | 5 +- block/blk.h | 1 + include/linux/lockdep.h | 50 +- include/linux/spinlock.h | 15 + include/linux/workqueue.h | 28 +- kernel/locking/lockdep.c | 887 +++++++++++++++--- kernel/locking/lockdep_internals.h | 3 +- kernel/locking/lockdep_proc.c | 12 +- kernel/workqueue.c | 59 +- lib/locking-selftest.c | 2 + tools/lib/lockdep/include/liblockdep/common.h | 2 + tools/lib/lockdep/include/liblockdep/mutex.h | 11 +- tools/lib/lockdep/run_tests.sh | 6 +- tools/lib/lockdep/tests/ABBA.c | 9 + 14 files changed, 910 insertions(+), 180 deletions(-)
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
PATCH v7 1/23 locking/lockdep: Fix two 32-bit compiler warnings
Use %zu to format size_t instead of %lu to avoid that the compiler complains about a mismatch between format specifier and argument on 32-bit systems.
--- kernel/locking/lockdep.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
kernel/locking/lockdep.c +2 -2
@@ -4278,7 +4278,7 @@ void __init lockdep_init(void)printk ("... MAX_LOCKDEP_CHAINS: %lu\n" ,MAX_LOCKDEP_CHAINS );printk ("... CHAINHASH_SIZE: %lu\n" ,CHAINHASH_SIZE ); - printk(" memory used by lock dependency info: %lu kB\n", + printk(" memory used by lock dependency info: %zu kB\n", (sizeof(struct lock_class) * MAX_LOCKDEP_KEYS + sizeof(struct list_head) * CLASSHASH_SIZE + sizeof(struct lock_list) * MAX_LOCKDEP_ENTRIES +
@@ -4290,7 +4290,7 @@ void __init lockdep_init(void) ) / 1024 ); -printk (" per task-struct memory footprint: %lu bytes\n" , +printk (" per task-struct memory footprint: %zu bytes\n" ,sizeof (struct held_lock ) *MAX_LOCK_DEPTH ); }
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
tip-bot for Bart Van Assche
merge bot[tip:locking/core] locking/lockdep: Fix two 32-bit compiler warnings
locking/lockdep: Fix two 32-bit compiler warnings
Commit-ID: 09d75ecb122d8b600d76e3b8d53a10ffbe3bcec2 Gitweb: https://git.kernel.org/tip/09d75ecb122d8b600d76e3b8d53a10ffbe3bcec2 Author: Bart Van Assche <[email protected]> AuthorDate: Thu, 14 Feb 2019 15:00:36 -0800 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 28 Feb 2019 07:55:38 +0100
locking/lockdep: Fix two 32-bit compiler warnings
Use %zu to format size_t instead of %lu to avoid that the compiler complains about a mismatch between format specifier and argument on 32-bit systems.
--- kernel/locking/lockdep.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
kernel/locking/lockdep.c +2 -2
@@ -4266,7 +4266,7 @@ void __init lockdep_init(void)printk ("... MAX_LOCKDEP_CHAINS: %lu\n" ,MAX_LOCKDEP_CHAINS );printk ("... CHAINHASH_SIZE: %lu\n" ,CHAINHASH_SIZE ); - printk(" memory used by lock dependency info: %lu kB\n", + printk(" memory used by lock dependency info: %zu kB\n", (sizeof(struct lock_class) * MAX_LOCKDEP_KEYS + sizeof(struct list_head) * CLASSHASH_SIZE + sizeof(struct lock_list) * MAX_LOCKDEP_ENTRIES +
@@ -4278,7 +4278,7 @@ void __init lockdep_init(void) ) / 1024 ); -printk (" per task-struct memory footprint: %lu bytes\n" , +printk (" per task-struct memory footprint: %zu bytes\n" ,sizeof (struct held_lock ) *MAX_LOCK_DEPTH ); }
PATCH v7 2/23 locking/lockdep: Fix reported required memory size (1/2)
In reply to Bart Van AsscheChange the sizeof(array element time) * (array size) expressions into sizeof(array). This fixes the size computations of the classhash_table[] and chainhash_table[] arrays. Commit a63f38cc4ccf ("locking/lockdep:
Convert hash tables to hlists") namely changed the type of the elements of that array from struct list_head into struct hlist_head.
--- kernel/locking/lockdep.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
kernel/locking/lockdep.c +7 -7
@@ -4279,19 +4279,19 @@ void __init lockdep_init(void)printk ("... CHAINHASH_SIZE: %lu\n" ,CHAINHASH_SIZE );printk (" memory used by lock dependency info: %zu kB\n" , - (sizeof (struct lock_class ) *MAX_LOCKDEP_KEYS + -sizeof (struct list_head ) *CLASSHASH_SIZE + -sizeof (struct lock_list ) *MAX_LOCKDEP_ENTRIES + -sizeof (struct lock_chain ) *MAX_LOCKDEP_CHAINS + -sizeof (struct list_head ) *CHAINHASH_SIZE + (sizeof (lock_classes) + +sizeof (classhash_table) + +sizeof (list_entries) + +sizeof (lock_chains) + +sizeof (chainhash_table) #ifdef CONFIG_PROVE_LOCKING - +sizeof (struct circular_queue ) + +sizeof (lock_cq) #endif ) /1024 );printk (" per task-struct memory footprint: %zu bytes\n" , -sizeof (struct held_lock ) *MAX_LOCK_DEPTH ); +sizeof (((struct task_struct *)NULL )->held_locks)); } static void
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
tip-bot for Bart Van Assche
merge bot[tip:locking/core] locking/lockdep: Fix reported required memory size (1/2)
locking/lockdep: Fix reported required memory size (1/2)
Commit-ID: 7ff8517e1034f26dde03d6df4026f085480408f0 Gitweb: https://git.kernel.org/tip/7ff8517e1034f26dde03d6df4026f085480408f0 Author: Bart Van Assche <[email protected]> AuthorDate: Thu, 14 Feb 2019 15:00:37 -0800 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 28 Feb 2019 07:55:39 +0100
locking/lockdep: Fix reported required memory size (1/2)
Change the sizeof(array element time) * (array size) expressions into sizeof(array). This fixes the size computations of the classhash_table[] and chainhash_table[] arrays.
The reason is that commit:
a63f38cc4ccf ("locking/lockdep: Convert hash tables to hlists")
changed the type of the elements of that array from 'struct list_head' into 'struct hlist_head'.
--- kernel/locking/lockdep.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
kernel/locking/lockdep.c +7 -7
@@ -4267,19 +4267,19 @@ void __init lockdep_init(void)printk ("... CHAINHASH_SIZE: %lu\n" ,CHAINHASH_SIZE );printk (" memory used by lock dependency info: %zu kB\n" , - (sizeof (struct lock_class ) *MAX_LOCKDEP_KEYS + -sizeof (struct list_head ) *CLASSHASH_SIZE + -sizeof (struct lock_list ) *MAX_LOCKDEP_ENTRIES + -sizeof (struct lock_chain ) *MAX_LOCKDEP_CHAINS + -sizeof (struct list_head ) *CHAINHASH_SIZE + (sizeof (lock_classes) + +sizeof (classhash_table) + +sizeof (list_entries) + +sizeof (lock_chains) + +sizeof (chainhash_table) #ifdef CONFIG_PROVE_LOCKING - +sizeof (struct circular_queue ) + +sizeof (lock_cq) #endif ) /1024 );printk (" per task-struct memory footprint: %zu bytes\n" , -sizeof (struct held_lock ) *MAX_LOCK_DEPTH ); +sizeof (((struct task_struct *)NULL )->held_locks)); } static void
PATCH v7 3/23 locking/lockdep: Fix reported required memory size (2/2)
In reply to Bart Van AsscheLock chains are only tracked with CONFIG_PROVE_LOCKING=y. Do not report the memory required for the lock chain array if CONFIG_PROVE_LOCKING=n. See also commit ca58abcb4a6d ("lockdep: sanitise CONFIG_PROVE_LOCKING").
Include the size of the chain_hlocks[] array.
--- kernel/locking/lockdep.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
kernel/locking/lockdep.c +2 -1
@@ -4282,10 +4282,11 @@ void __init lockdep_init(void) (sizeof (lock_classes) +sizeof (classhash_table) +sizeof (list_entries) + -sizeof (lock_chains) +sizeof (chainhash_table) #ifdef CONFIG_PROVE_LOCKING +sizeof (lock_cq) + +sizeof (lock_chains) + +sizeof (chain_hlocks) #endif ) /1024 );
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
tip-bot for Bart Van Assche
merge bot[tip:locking/core] locking/lockdep: Fix reported required memory size (2/2)
locking/lockdep: Fix reported required memory size (2/2)
Commit-ID: 15ea86b58c71d05e0921bebcf707aa30e43e9e25 Gitweb: https://git.kernel.org/tip/15ea86b58c71d05e0921bebcf707aa30e43e9e25 Author: Bart Van Assche <[email protected]> AuthorDate: Thu, 14 Feb 2019 15:00:38 -0800 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 28 Feb 2019 07:55:39 +0100
locking/lockdep: Fix reported required memory size (2/2)
Lock chains are only tracked with CONFIG_PROVE_LOCKING=y. Do not report the memory required for the lock chain array if CONFIG_PROVE_LOCKING=n. See also commit:
ca58abcb4a6d ("lockdep: sanitise CONFIG_PROVE_LOCKING")
Include the size of the chain_hlocks[] array.
--- kernel/locking/lockdep.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
kernel/locking/lockdep.c +2 -1
@@ -4270,10 +4270,11 @@ void __init lockdep_init(void) (sizeof (lock_classes) +sizeof (classhash_table) +sizeof (list_entries) + -sizeof (lock_chains) +sizeof (chainhash_table) #ifdef CONFIG_PROVE_LOCKING +sizeof (lock_cq) + +sizeof (lock_chains) + +sizeof (chain_hlocks) #endif ) /1024 );
PATCH v7 4/23 locking/lockdep: Avoid that add_chain_cache() adds an invalid chain to the cache
In reply to Bart Van AsscheMake sure that add_chain_cache() returns 0 and does not modify the chain hash if nr_chain_hlocks == MAX_LOCKDEP_CHAIN_HLOCKS before this function is called.
--- kernel/locking/lockdep.c | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-)
kernel/locking/lockdep.c +1 -10
@@ -2206,16 +2206,8 @@ static inline int add_chain_cache(struct task_struct *curr, chain_hlocks[chain->base + j] = lock_id; } chain_hlocks[chain->base + j] = class - lock_classes; - } - -if (nr_chain_hlocks <MAX_LOCKDEP_CHAIN_HLOCKS ) nr_chain_hlocks += chain->depth; - -#ifdef CONFIG_DEBUG_LOCKDEP -/* -* Important for check_no_collision(). -*/ -if (unlikely (nr_chain_hlocks >MAX_LOCKDEP_CHAIN_HLOCKS )) { + }else {if (!debug_locks_off_graph_unlock ())return 0 ;
@@ -2223,7 +2215,6 @@ static inline int add_chain_cache(struct task_struct *curr,dump_stack ();return 0 ; } -#endif hlist_add_head_rcu (&chain->entry, hash_head);debug_atomic_inc (chain_lookup_misses);
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
tip-bot for Bart Van Assche
merge bot[tip:locking/core] locking/lockdep: Avoid that add_chain_cache() adds an invalid chain to the cache
locking/lockdep: Avoid that add_chain_cache() adds an invalid chain to the cache
Commit-ID: 523b113bace5e64e860d8c61d7aa25057d274753 Gitweb: https://git.kernel.org/tip/523b113bace5e64e860d8c61d7aa25057d274753 Author: Bart Van Assche <[email protected]> AuthorDate: Thu, 14 Feb 2019 15:00:39 -0800 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 28 Feb 2019 07:55:40 +0100
locking/lockdep: Avoid that add_chain_cache() adds an invalid chain to the cache
Make sure that add_chain_cache() returns 0 and does not modify the chain hash if nr_chain_hlocks == MAX_LOCKDEP_CHAIN_HLOCKS before this function is called.
--- kernel/locking/lockdep.c | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-)
kernel/locking/lockdep.c +1 -10
@@ -2195,16 +2195,8 @@ static inline int add_chain_cache(struct task_struct *curr, chain_hlocks[chain->base + j] = lock_id; } chain_hlocks[chain->base + j] = class - lock_classes; - } - -if (nr_chain_hlocks <MAX_LOCKDEP_CHAIN_HLOCKS ) nr_chain_hlocks += chain->depth; - -#ifdef CONFIG_DEBUG_LOCKDEP -/* -* Important for check_no_collision(). -*/ -if (unlikely (nr_chain_hlocks >MAX_LOCKDEP_CHAIN_HLOCKS )) { + }else {if (!debug_locks_off_graph_unlock ())return 0 ;
@@ -2212,7 +2204,6 @@ static inline int add_chain_cache(struct task_struct *curr,dump_stack ();return 0 ; } -#endif hlist_add_head_rcu (&chain->entry, hash_head);debug_atomic_inc (chain_lookup_misses);
PATCH v7 5/23 locking/lockdep: Reorder struct lock_class members
In reply to Bart Van AsscheThis patch does not change any functionality but makes the patch that frees lock classes that are no longer in use easier to read.
--- include/linux/lockdep.h | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
include/linux/lockdep.h +7 -7
@@ -76,6 +76,13 @@ struct lock_class {*/ struct list_head lock_entry; +/* +* These fields represent a directed graph of lock dependencies, +* to every node we attach a list of "forward" and a list of +* "backward" graph nodes. +*/ +struct list_head locks_after, locks_before; +struct lockdep_subclass_key *key;unsigned int subclass;unsigned int dep_gen_id;
@@ -86,13 +93,6 @@ struct lock_class {unsigned long usage_mask;struct stack_trace usage_traces[XXX_LOCK_USAGE_STATES ]; -/* -* These fields represent a directed graph of lock dependencies, -* to every node we attach a list of "forward" and a list of -* "backward" graph nodes. -*/ -struct list_head locks_after, locks_before; -/* * Generation counter, when doing certain classes of graph walking, * to ensure that we check one node only once:
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
tip-bot for Bart Van Assche
merge bot[tip:locking/core] locking/lockdep: Reorder struct lock_class members
locking/lockdep: Reorder struct lock_class members
Commit-ID: 09329d1c2024522308ca4de977fc6bba753bab1a Gitweb: https://git.kernel.org/tip/09329d1c2024522308ca4de977fc6bba753bab1a Author: Bart Van Assche <[email protected]> AuthorDate: Thu, 14 Feb 2019 15:00:40 -0800 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 28 Feb 2019 07:55:40 +0100
locking/lockdep: Reorder struct lock_class members
This patch does not change any functionality but makes the patch that frees lock classes that are no longer in use easier to read.
--- include/linux/lockdep.h | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
include/linux/lockdep.h +7 -7
@@ -76,6 +76,13 @@ struct lock_class {*/ struct list_head lock_entry; +/* +* These fields represent a directed graph of lock dependencies, +* to every node we attach a list of "forward" and a list of +* "backward" graph nodes. +*/ +struct list_head locks_after, locks_before; +struct lockdep_subclass_key *key;unsigned int subclass;unsigned int dep_gen_id;
@@ -86,13 +93,6 @@ struct lock_class {unsigned long usage_mask;struct stack_trace usage_traces[XXX_LOCK_USAGE_STATES ]; -/* -* These fields represent a directed graph of lock dependencies, -* to every node we attach a list of "forward" and a list of -* "backward" graph nodes. -*/ -struct list_head locks_after, locks_before; -/* * Generation counter, when doing certain classes of graph walking, * to ensure that we check one node only once:
PATCH v7 6/23 locking/lockdep: Make zap_class() remove all matching lock order entries
In reply to Bart Van AsscheMake sure that all lock order entries that refer to a class are removed from the list_entries[] array when a kernel module is unloaded.
--- include/linux/lockdep.h | 1 + kernel/locking/lockdep.c | 19 +++++++++++++------ 2 files changed, 14 insertions(+), 6 deletions(-)
include/linux/lockdep.h +1 -0
@@ -178,6 +178,7 @@ static inline void lockdep_copy_map(struct lockdep_map *to,struct lock_list {struct list_head entry;struct lock_class *class; +struct lock_class *links_to;struct stack_trace trace;int distance;
kernel/locking/lockdep.c +13 -6
@@ -859,7 +859,8 @@ static struct lock_list *alloc_list_entry(void)/* * Add a new dependency to the head of the list: */ -static int add_lock_to_list (struct lock_class *this,struct list_head *head, +static int add_lock_to_list (struct lock_class *this, +struct lock_class *links_to,struct list_head *head,unsigned long ip,int distance,struct stack_trace *trace) {
@@ -873,6 +874,7 @@ static int add_lock_to_list(struct lock_class *this, struct list_head *head,return 0 ; entry->class = this; + entry->links_to = links_to; entry->distance = distance; entry->trace = *trace;/*
@@ -1918,14 +1920,14 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev,* Ok, all validations passed, add the new lock * to the previous lock's dependency list: */ - ret =add_lock_to_list (hlock_class (next), + ret =add_lock_to_list (hlock_class (next),hlock_class (prev), &hlock_class (prev)->locks_after, next->acquire_ip, distance, trace);if (!ret)return 0 ; - ret =add_lock_to_list (hlock_class (prev), + ret =add_lock_to_list (hlock_class (prev),hlock_class (next), &hlock_class (next)->locks_before, next->acquire_ip, distance, trace);if (!ret)
@@ -4119,15 +4121,20 @@ void lockdep_reset(void)*/ static void zap_class (struct lock_class *class) { +struct lock_list *entry;int i;/* * Remove all dependencies this lock is * involved in: */ -for (i =0 ; i < nr_list_entries; i++) { -if (list_entries[i].class == class) -list_del_rcu (&list_entries[i].entry); +for (i =0 , entry = list_entries; i < nr_list_entries; i++, entry++) { +if (entry->class != class && entry->links_to != class) +continue ; +list_del_rcu (&entry->entry); +/* Clear .class and .links_to to avoid double removal. */ +WRITE_ONCE (entry->class,NULL ); +WRITE_ONCE (entry->links_to,NULL ); }/* * Unhash the class and remove it from the all_lock_classes list:
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
tip-bot for Bart Van Assche
merge bot[tip:locking/core] locking/lockdep: Make zap_class() remove all matching lock order entries
locking/lockdep: Make zap_class() remove all matching lock order entries
Commit-ID: 86cffb80a525f7b8f969c8c79669d383e02f17d1 Gitweb: https://git.kernel.org/tip/86cffb80a525f7b8f969c8c79669d383e02f17d1 Author: Bart Van Assche <[email protected]> AuthorDate: Thu, 14 Feb 2019 15:00:41 -0800 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 28 Feb 2019 07:55:40 +0100
locking/lockdep: Make zap_class() remove all matching lock order entries
Make sure that all lock order entries that refer to a class are removed from the list_entries[] array when a kernel module is unloaded.
--- include/linux/lockdep.h | 1 + kernel/locking/lockdep.c | 19 +++++++++++++------ 2 files changed, 14 insertions(+), 6 deletions(-)
include/linux/lockdep.h +1 -0
@@ -178,6 +178,7 @@ static inline void lockdep_copy_map(struct lockdep_map *to,struct lock_list {struct list_head entry;struct lock_class *class; +struct lock_class *links_to;struct stack_trace trace;int distance;
kernel/locking/lockdep.c +13 -6
@@ -859,7 +859,8 @@ static struct lock_list *alloc_list_entry(void)/* * Add a new dependency to the head of the list: */ -static int add_lock_to_list (struct lock_class *this,struct list_head *head, +static int add_lock_to_list (struct lock_class *this, +struct lock_class *links_to,struct list_head *head,unsigned long ip,int distance,struct stack_trace *trace) {
@@ -873,6 +874,7 @@ static int add_lock_to_list(struct lock_class *this, struct list_head *head,return 0 ; entry->class = this; + entry->links_to = links_to; entry->distance = distance; entry->trace = *trace;/*
@@ -1907,14 +1909,14 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev,* Ok, all validations passed, add the new lock * to the previous lock's dependency list: */ - ret =add_lock_to_list (hlock_class (next), + ret =add_lock_to_list (hlock_class (next),hlock_class (prev), &hlock_class (prev)->locks_after, next->acquire_ip, distance, trace);if (!ret)return 0 ; - ret =add_lock_to_list (hlock_class (prev), + ret =add_lock_to_list (hlock_class (prev),hlock_class (next), &hlock_class (next)->locks_before, next->acquire_ip, distance, trace);if (!ret)
@@ -4107,15 +4109,20 @@ void lockdep_reset(void)*/ static void zap_class (struct lock_class *class) { +struct lock_list *entry;int i;/* * Remove all dependencies this lock is * involved in: */ -for (i =0 ; i < nr_list_entries; i++) { -if (list_entries[i].class == class) -list_del_rcu (&list_entries[i].entry); +for (i =0 , entry = list_entries; i < nr_list_entries; i++, entry++) { +if (entry->class != class && entry->links_to != class) +continue ; +list_del_rcu (&entry->entry); +/* Clear .class and .links_to to avoid double removal. */ +WRITE_ONCE (entry->class,NULL ); +WRITE_ONCE (entry->links_to,NULL ); }/* * Unhash the class and remove it from the all_lock_classes list:
PATCH v7 7/23 locking/lockdep: Initialize the locks_before and locks_after lists earlier
In reply to Bart Van AsscheThis patch does not change any functionality. A later patch will reuse lock classes that have been freed. In combination with that patch this patch wil have the effect of initializing lock class order lists once instead of every time a lock class structure is reinitialized.
--- kernel/locking/lockdep.c | 29 +++++++++++++++++++++++++++-- 1 file changed, 27 insertions(+), 2 deletions(-)
kernel/locking/lockdep.c +27 -2
@@ -735,6 +735,25 @@ static bool assign_lock_key(struct lockdep_map *lock)return true; } +/* +* Initialize the lock_classes[] array elements. +*/ +static void init_data_structures_once (void ) +{ +static bool initialization_happened; +int i; + +if (likely (initialization_happened)) +return ; + + initialization_happened = true; + +for (i =0 ; i <ARRAY_SIZE (lock_classes); i++) { +INIT_LIST_HEAD (&lock_classes[i].locks_after); +INIT_LIST_HEAD (&lock_classes[i].locks_before); + } +} +/* * Register a lock's class in the hash-table, if the class is not present * yet. Otherwise we look it up. We cache the result in the lock object
@@ -775,6 +794,8 @@ register_lock_class(struct lockdep_map *lock, unsigned int subclass, int force) goto out_unlock_set; } +init_data_structures_once (); +/* * Allocate a new key from the static array, and add it to * the hash:
@@ -793,8 +814,8 @@ register_lock_class(struct lockdep_map *lock, unsigned int subclass, int force) class->key = key; class->name = lock->name; class->subclass = subclass; -INIT_LIST_HEAD (&class->locks_before); -INIT_LIST_HEAD (&class->locks_after); +WARN_ON_ONCE (!list_empty (&class->locks_before)); +WARN_ON_ONCE (!list_empty (&class->locks_after)); class->name_version =count_matching_names (class);/* * We use RCU's safe list-add method to make
@@ -4167,6 +4188,8 @@ void lockdep_free_key_range(void *start, unsigned long size)int i;int locked; +init_data_structures_once (); +raw_local_irq_save (flags); locked =graph_lock ();
@@ -4230,6 +4253,8 @@ void lockdep_reset_lock(struct lockdep_map *lock)unsigned long flags;int j, locked; +init_data_structures_once (); +raw_local_irq_save (flags); locked =graph_lock ();
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
tip-bot for Bart Van Assche
merge bot[tip:locking/core] locking/lockdep: Initialize the locks_before and locks_after lists earlier
locking/lockdep: Initialize the locks_before and locks_after lists earlier
Commit-ID: feb0a3865ed2f7d66a1f2686f7ad784422c249ad Gitweb: https://git.kernel.org/tip/feb0a3865ed2f7d66a1f2686f7ad784422c249ad Author: Bart Van Assche <[email protected]> AuthorDate: Thu, 14 Feb 2019 15:00:42 -0800 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 28 Feb 2019 07:55:41 +0100
locking/lockdep: Initialize the locks_before and locks_after lists earlier
This patch does not change any functionality. A later patch will reuse lock classes that have been freed. In combination with that patch this patch wil have the effect of initializing lock class order lists once instead of every time a lock class structure is reinitialized.
--- kernel/locking/lockdep.c | 29 +++++++++++++++++++++++++++-- 1 file changed, 27 insertions(+), 2 deletions(-)
kernel/locking/lockdep.c +27 -2
@@ -735,6 +735,25 @@ static bool assign_lock_key(struct lockdep_map *lock)return true; } +/* +* Initialize the lock_classes[] array elements. +*/ +static void init_data_structures_once (void ) +{ +static bool initialization_happened; +int i; + +if (likely (initialization_happened)) +return ; + + initialization_happened = true; + +for (i =0 ; i <ARRAY_SIZE (lock_classes); i++) { +INIT_LIST_HEAD (&lock_classes[i].locks_after); +INIT_LIST_HEAD (&lock_classes[i].locks_before); + } +} +/* * Register a lock's class in the hash-table, if the class is not present * yet. Otherwise we look it up. We cache the result in the lock object
@@ -775,6 +794,8 @@ register_lock_class(struct lockdep_map *lock, unsigned int subclass, int force) goto out_unlock_set; } +init_data_structures_once (); +/* * Allocate a new key from the static array, and add it to * the hash:
@@ -793,8 +814,8 @@ register_lock_class(struct lockdep_map *lock, unsigned int subclass, int force) class->key = key; class->name = lock->name; class->subclass = subclass; -INIT_LIST_HEAD (&class->locks_before); -INIT_LIST_HEAD (&class->locks_after); +WARN_ON_ONCE (!list_empty (&class->locks_before)); +WARN_ON_ONCE (!list_empty (&class->locks_after)); class->name_version =count_matching_names (class);/* * We use RCU's safe list-add method to make
@@ -4155,6 +4176,8 @@ void lockdep_free_key_range(void *start, unsigned long size)int i;int locked; +init_data_structures_once (); +raw_local_irq_save (flags); locked =graph_lock ();
@@ -4218,6 +4241,8 @@ void lockdep_reset_lock(struct lockdep_map *lock)unsigned long flags;int j, locked; +init_data_structures_once (); +raw_local_irq_save (flags); locked =graph_lock ();
PATCH v7 8/23 locking/lockdep: Split lockdep_free_key_range() and lockdep_reset_lock()
In reply to Bart Van AsscheThis patch does not change the behavior of these functions but makes the patch that frees unused lock classes easier to read.
--- kernel/locking/lockdep.c | 72 ++++++++++++++++++++-------------------- 1 file changed, 36 insertions(+), 36 deletions(-)
kernel/locking/lockdep.c +36 -36
@@ -4172,6 +4172,24 @@ static inline int within(const void *addr, void *start, unsigned long size)return addr >= start && addr < start + size; } +static void __lockdep_free_key_range (void *start,unsigned long size) +{ +struct lock_class *class; +struct hlist_head *head; +int i; + +/* Unhash all classes that were created by a module. */ +for (i =0 ; i <CLASSHASH_SIZE ; i++) { + head = classhash_table + i; +hlist_for_each_entry_rcu (class, head, hash_entry) { +if (!within (class->key, start, size) && + !within (class->name, start, size)) +continue ; +zap_class (class); + } + } +} +/* * Used in module.c to remove lock classes from memory that is going to be * freed; and possibly re-used by other modules.
@@ -4182,30 +4200,14 @@ static inline int within(const void *addr, void *start, unsigned long size)*/ void lockdep_free_key_range (void *start,unsigned long size) { -struct lock_class *class; -struct hlist_head *head;unsigned long flags; -int i;int locked;init_data_structures_once ();raw_local_irq_save (flags); locked =graph_lock (); - -/* -* Unhash all classes that were created by this module: -*/ -for (i =0 ; i <CLASSHASH_SIZE ; i++) { - head = classhash_table + i; -hlist_for_each_entry_rcu (class, head, hash_entry) { -if (within (class->key, start, size)) -zap_class (class); -else if (within (class->name, start, size)) -zap_class (class); - } - } - +__lockdep_free_key_range (start, size);if (locked)graph_unlock ();raw_local_irq_restore (flags);
@@ -4247,16 +4249,11 @@ static bool lock_class_cache_is_registered(struct lockdep_map *lock)return false; } -void lockdep_reset_lock (struct lockdep_map *lock) +/* The caller must hold the graph lock. Does not sleep. */ +static void __lockdep_reset_lock (struct lockdep_map *lock) {struct lock_class *class; -unsigned long flags; -int j, locked; - -init_data_structures_once (); - -raw_local_irq_save (flags); - locked =graph_lock (); +int j;/* * Remove all classes this lock might have:
@@ -4273,19 +4270,22 @@ void lockdep_reset_lock(struct lockdep_map *lock)* Debug check: in the end all mapped classes should * be gone. */ -if (unlikely (lock_class_cache_is_registered (lock))) { -if (debug_locks_off_graph_unlock ()) { -/* -* We all just reset everything, how did it match? -*/ -WARN_ON (1 ); - } - goto out_restore; - } +if (WARN_ON_ONCE (lock_class_cache_is_registered (lock))) +debug_locks_off (); +} + +void lockdep_reset_lock (struct lockdep_map *lock) +{ +unsigned long flags; +int locked; + +init_data_structures_once (); + +raw_local_irq_save (flags); + locked =graph_lock (); +__lockdep_reset_lock (lock);if (locked)graph_unlock (); - -out_restore:raw_local_irq_restore (flags); }
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
tip-bot for Bart Van Assche
merge bot[tip:locking/core] locking/lockdep: Split lockdep_free_key_range() and lockdep_reset_lock()
locking/lockdep: Split lockdep_free_key_range() and lockdep_reset_lock()
Commit-ID: 956f3563a8387beb7758f2e8ee483639ef91afc6 Gitweb: https://git.kernel.org/tip/956f3563a8387beb7758f2e8ee483639ef91afc6 Author: Bart Van Assche <[email protected]> AuthorDate: Thu, 14 Feb 2019 15:00:43 -0800 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 28 Feb 2019 07:55:42 +0100
locking/lockdep: Split lockdep_free_key_range() and lockdep_reset_lock()
This patch does not change the behavior of these functions but makes the patch that frees unused lock classes easier to read.
--- kernel/locking/lockdep.c | 72 ++++++++++++++++++++++++------------------------ 1 file changed, 36 insertions(+), 36 deletions(-)
kernel/locking/lockdep.c +36 -36
@@ -4160,6 +4160,24 @@ static inline int within(const void *addr, void *start, unsigned long size)return addr >= start && addr < start + size; } +static void __lockdep_free_key_range (void *start,unsigned long size) +{ +struct lock_class *class; +struct hlist_head *head; +int i; + +/* Unhash all classes that were created by a module. */ +for (i =0 ; i <CLASSHASH_SIZE ; i++) { + head = classhash_table + i; +hlist_for_each_entry_rcu (class, head, hash_entry) { +if (!within (class->key, start, size) && + !within (class->name, start, size)) +continue ; +zap_class (class); + } + } +} +/* * Used in module.c to remove lock classes from memory that is going to be * freed; and possibly re-used by other modules.
@@ -4170,30 +4188,14 @@ static inline int within(const void *addr, void *start, unsigned long size)*/ void lockdep_free_key_range (void *start,unsigned long size) { -struct lock_class *class; -struct hlist_head *head;unsigned long flags; -int i;int locked;init_data_structures_once ();raw_local_irq_save (flags); locked =graph_lock (); - -/* -* Unhash all classes that were created by this module: -*/ -for (i =0 ; i <CLASSHASH_SIZE ; i++) { - head = classhash_table + i; -hlist_for_each_entry_rcu (class, head, hash_entry) { -if (within (class->key, start, size)) -zap_class (class); -else if (within (class->name, start, size)) -zap_class (class); - } - } - +__lockdep_free_key_range (start, size);if (locked)graph_unlock ();raw_local_irq_restore (flags);
@@ -4235,16 +4237,11 @@ static bool lock_class_cache_is_registered(struct lockdep_map *lock)return false; } -void lockdep_reset_lock (struct lockdep_map *lock) +/* The caller must hold the graph lock. Does not sleep. */ +static void __lockdep_reset_lock (struct lockdep_map *lock) {struct lock_class *class; -unsigned long flags; -int j, locked; - -init_data_structures_once (); - -raw_local_irq_save (flags); - locked =graph_lock (); +int j;/* * Remove all classes this lock might have:
@@ -4261,19 +4258,22 @@ void lockdep_reset_lock(struct lockdep_map *lock)* Debug check: in the end all mapped classes should * be gone. */ -if (unlikely (lock_class_cache_is_registered (lock))) { -if (debug_locks_off_graph_unlock ()) { -/* -* We all just reset everything, how did it match? -*/ -WARN_ON (1 ); - } - goto out_restore; - } +if (WARN_ON_ONCE (lock_class_cache_is_registered (lock))) +debug_locks_off (); +} + +void lockdep_reset_lock (struct lockdep_map *lock) +{ +unsigned long flags; +int locked; + +init_data_structures_once (); + +raw_local_irq_save (flags); + locked =graph_lock (); +__lockdep_reset_lock (lock);if (locked)graph_unlock (); - -out_restore:raw_local_irq_restore (flags); }
PATCH v7 9/23 locking/lockdep: Make it easy to detect whether or not inside a selftest
In reply to Bart Van AsscheThe patch that frees unused lock classes will modify the behavior of lockdep_free_key_range() and lockdep_reset_lock() depending on whether or not these functions are called from the context of the lockdep selftests. Hence make it easy to detect whether or not lockdep code is called from the context of a lockdep selftest.
--- include/linux/lockdep.h | 5 +++++ kernel/locking/lockdep.c | 6 ++++++ lib/locking-selftest.c | 2 ++ 3 files changed, 13 insertions(+)
include/linux/lockdep.h +5 -0
@@ -265,6 +265,7 @@ extern void lockdep_reset(void);extern void lockdep_reset_lock (struct lockdep_map *lock);extern void lockdep_free_key_range (void *start,unsigned long size); extern asmlinkage void lockdep_sys_exit(void); +extern void lockdep_set_selftest_task (struct task_struct *task);extern void lockdep_off (void );extern void lockdep_on (void );
@@ -395,6 +396,10 @@ static inline void lockdep_on(void) { } +static inline void lockdep_set_selftest_task (struct task_struct *task) +{ +} +# define lock_acquire (l, s, t, r, c, n, i) do { } while (0)# define lock_release (l, n, i) do { } while (0)# define lock_downgrade (l, i) do { } while (0)
kernel/locking/lockdep.c +6 -0
@@ -81,6 +81,7 @@ module_param(lock_stat, int, 0644);* code to recurse back into the lockdep code... */ static arch_spinlock_t lockdep_lock = (arch_spinlock_t )__ARCH_SPIN_LOCK_UNLOCKED; +static struct task_struct *lockdep_selftest_task_struct;static int graph_lock (void ) {
@@ -331,6 +332,11 @@ void lockdep_on(void) }EXPORT_SYMBOL (lockdep_on); +void lockdep_set_selftest_task (struct task_struct *task) +{ + lockdep_selftest_task_struct = task; +} +/* * Debugging switches: */
lib/locking-selftest.c +2 -0
@@ -1989,6 +1989,7 @@ void locking_selftest(void)init_shared_classes (); debug_locks_silent = !debug_locks_verbose; +lockdep_set_selftest_task (current);DO_TESTCASE_6R ("A-A deadlock" ,AA );DO_TESTCASE_6R ("A-B-B-A deadlock" ,ABBA );
@@ -2097,5 +2098,6 @@ void locking_selftest(void)printk ("---------------------------------\n" ); debug_locks =1 ; } +lockdep_set_selftest_task (NULL ); debug_locks_silent =0 ; }
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
tip-bot for Bart Van Assche
merge bot[tip:locking/core] locking/lockdep: Make it easy to detect whether or not inside a selftest
locking/lockdep: Make it easy to detect whether or not inside a selftest
Commit-ID: cdc84d794947b5431c0a6916c303aee7114819d2 Gitweb: https://git.kernel.org/tip/cdc84d794947b5431c0a6916c303aee7114819d2 Author: Bart Van Assche <[email protected]> AuthorDate: Thu, 14 Feb 2019 15:00:44 -0800 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 28 Feb 2019 07:55:43 +0100
locking/lockdep: Make it easy to detect whether or not inside a selftest
The patch that frees unused lock classes will modify the behavior of lockdep_free_key_range() and lockdep_reset_lock() depending on whether or not these functions are called from the context of the lockdep selftests. Hence make it easy to detect whether or not lockdep code is called from the context of a lockdep selftest.
--- include/linux/lockdep.h | 5 +++++ kernel/locking/lockdep.c | 6 ++++++ lib/locking-selftest.c | 2 ++ 3 files changed, 13 insertions(+)
include/linux/lockdep.h +5 -0
@@ -265,6 +265,7 @@ extern void lockdep_reset(void);extern void lockdep_reset_lock (struct lockdep_map *lock);extern void lockdep_free_key_range (void *start,unsigned long size); extern asmlinkage void lockdep_sys_exit(void); +extern void lockdep_set_selftest_task (struct task_struct *task);extern void lockdep_off (void );extern void lockdep_on (void );
@@ -395,6 +396,10 @@ static inline void lockdep_on(void) { } +static inline void lockdep_set_selftest_task (struct task_struct *task) +{ +} +# define lock_acquire (l, s, t, r, c, n, i) do { } while (0)# define lock_release (l, n, i) do { } while (0)# define lock_downgrade (l, i) do { } while (0)
kernel/locking/lockdep.c +6 -0
@@ -81,6 +81,7 @@ module_param(lock_stat, int, 0644);* code to recurse back into the lockdep code... */ static arch_spinlock_t lockdep_lock = (arch_spinlock_t )__ARCH_SPIN_LOCK_UNLOCKED; +static struct task_struct *lockdep_selftest_task_struct;static int graph_lock (void ) {
@@ -331,6 +332,11 @@ void lockdep_on(void) }EXPORT_SYMBOL (lockdep_on); +void lockdep_set_selftest_task (struct task_struct *task) +{ + lockdep_selftest_task_struct = task; +} +/* * Debugging switches: */
lib/locking-selftest.c +2 -0
@@ -1989,6 +1989,7 @@ void locking_selftest(void)init_shared_classes (); debug_locks_silent = !debug_locks_verbose; +lockdep_set_selftest_task (current);DO_TESTCASE_6R ("A-A deadlock" ,AA );DO_TESTCASE_6R ("A-B-B-A deadlock" ,ABBA );
@@ -2097,5 +2098,6 @@ void locking_selftest(void)printk ("---------------------------------\n" ); debug_locks =1 ; } +lockdep_set_selftest_task (NULL ); debug_locks_silent =0 ; }
PATCH v7 10/23 locking/lockdep: Update two outdated comments
In reply to Bart Van Asschesynchronize_sched() has been removed recently. Update the comments that refer to synchronize_sched().
--- kernel/locking/lockdep.c | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-)
kernel/locking/lockdep.c +3 -5
@@ -4200,9 +4200,9 @@ static void __lockdep_free_key_range(void *start, unsigned long size)* Used in module.c to remove lock classes from memory that is going to be * freed; and possibly re-used by other modules. * -* We will have had one sync_sched() before getting here, so we're guaranteed -* nobody will look up these exact classes -- they're properly dead but still -* allocated. +* We will have had one synchronize_rcu() before getting here, so we're +* guaranteed nobody will look up these exact classes -- they're properly dead +* but still allocated. */ void lockdep_free_key_range (void *start,unsigned long size) {
@@ -4221,8 +4221,6 @@ void lockdep_free_key_range(void *start, unsigned long size)/* * Wait for any possible iterators from look_up_lock_class() to pass * before continuing to free the memory they refer to. -* -* sync_sched() is sufficient because the read-side is IRQ disable. */ synchronize_rcu ();
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
tip-bot for Bart Van Assche
merge bot[tip:locking/core] locking/lockdep: Update two outdated comments
locking/lockdep: Update two outdated comments
Commit-ID: 29fc33fb7283970701355dc89badba4ed21c7092 Gitweb: https://git.kernel.org/tip/29fc33fb7283970701355dc89badba4ed21c7092 Author: Bart Van Assche <[email protected]> AuthorDate: Thu, 14 Feb 2019 15:00:45 -0800 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 28 Feb 2019 07:55:43 +0100
locking/lockdep: Update two outdated comments
synchronize_sched() has been removed recently. Update the comments that refer to synchronize_sched().
--- kernel/locking/lockdep.c | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-)
kernel/locking/lockdep.c +3 -5
@@ -4188,9 +4188,9 @@ static void __lockdep_free_key_range(void *start, unsigned long size)* Used in module.c to remove lock classes from memory that is going to be * freed; and possibly re-used by other modules. * -* We will have had one sync_sched() before getting here, so we're guaranteed -* nobody will look up these exact classes -- they're properly dead but still -* allocated. +* We will have had one synchronize_rcu() before getting here, so we're +* guaranteed nobody will look up these exact classes -- they're properly dead +* but still allocated. */ void lockdep_free_key_range (void *start,unsigned long size) {
@@ -4209,8 +4209,6 @@ void lockdep_free_key_range(void *start, unsigned long size)/* * Wait for any possible iterators from look_up_lock_class() to pass * before continuing to free the memory they refer to. -* -* sync_sched() is sufficient because the read-side is IRQ disable. */ synchronize_rcu ();
PATCH v7 11/23 locking/lockdep: Free lock classes that are no longer in use
In reply to Bart Van AsscheInstead of leaving lock classes that are no longer in use in the lock_classes array, reuse entries from that array that are no longer in use. Maintain a linked list of free lock classes with list head 'free_lock_class'. Only add freed lock classes to the free_lock_classes list after a grace period to avoid that a lock_classes[] element would be reused while an RCU reader is accessing it. Since the lockdep selftests run in a context where sleeping is not allowed and since the selftests require that lock resetting/zapping works with debug_locks off, make the behavior of lockdep_free_key_range() and lockdep_reset_lock() depend on whether or not these are called from the context of the lockdep selftests.
Thanks to Peter for having shown how to modify get_pending_free() such that that function does not have to sleep.
--- include/linux/lockdep.h | 9 +- kernel/locking/lockdep.c | 396 ++++++++++++++++++++++++++++++++++----- 2 files changed, 354 insertions(+), 51 deletions(-)
include/linux/lockdep.h +6 -3
@@ -63,7 +63,8 @@ extern struct lock_class_key __lockdep_no_validate__;#define LOCKSTAT_POINTS 4/* -* The lock-class itself: +* The lock-class itself. The order of the structure members matters. +* reinit_class() zeroes the key member and all subsequent members. */ struct lock_class {/*
@@ -72,7 +73,9 @@ struct lock_class {struct hlist_node hash_entry;/* -* global list of all lock-classes: +* Entry in all_lock_classes when in use. Entry in free_lock_classes +* when not in use. Instances that are being freed are on one of the +* zapped_classes lists. */ struct list_head lock_entry;
@@ -104,7 +107,7 @@ struct lock_class {unsigned long contention_point[LOCKSTAT_POINTS ];unsigned long contending_point[LOCKSTAT_POINTS ];#endif -}; +} __no_randomize_layout;#ifdef CONFIG_LOCK_STAT struct lock_time {
kernel/locking/lockdep.c +348 -48
558 lines not on this page · raw message
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
tip-bot for Bart Van Assche
merge bot[tip:locking/core] locking/lockdep: Free lock classes that are no longer in use
locking/lockdep: Free lock classes that are no longer in use
Commit-ID: a0b0fd53e1e67639b303b15939b9c653dbe7a8c4 Gitweb: https://git.kernel.org/tip/a0b0fd53e1e67639b303b15939b9c653dbe7a8c4 Author: Bart Van Assche <[email protected]> AuthorDate: Thu, 14 Feb 2019 15:00:46 -0800 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 28 Feb 2019 07:55:43 +0100
locking/lockdep: Free lock classes that are no longer in use
Instead of leaving lock classes that are no longer in use in the lock_classes array, reuse entries from that array that are no longer in use. Maintain a linked list of free lock classes with list head 'free_lock_class'. Only add freed lock classes to the free_lock_classes list after a grace period to avoid that a lock_classes[] element would be reused while an RCU reader is accessing it. Since the lockdep selftests run in a context where sleeping is not allowed and since the selftests require that lock resetting/zapping works with debug_locks off, make the behavior of lockdep_free_key_range() and lockdep_reset_lock() depend on whether or not these are called from the context of the lockdep selftests.
Thanks to Peter for having shown how to modify get_pending_free() such that that function does not have to sleep.
--- include/linux/lockdep.h | 9 +- kernel/locking/lockdep.c | 396 +++++++++++++++++++++++++++++++++++++++++------ 2 files changed, 354 insertions(+), 51 deletions(-)
include/linux/lockdep.h +6 -3
@@ -63,7 +63,8 @@ extern struct lock_class_key __lockdep_no_validate__;#define LOCKSTAT_POINTS 4/* -* The lock-class itself: +* The lock-class itself. The order of the structure members matters. +* reinit_class() zeroes the key member and all subsequent members. */ struct lock_class {/*
@@ -72,7 +73,9 @@ struct lock_class {struct hlist_node hash_entry;/* -* global list of all lock-classes: +* Entry in all_lock_classes when in use. Entry in free_lock_classes +* when not in use. Instances that are being freed are on one of the +* zapped_classes lists. */ struct list_head lock_entry;
@@ -104,7 +107,7 @@ struct lock_class {unsigned long contention_point[LOCKSTAT_POINTS ];unsigned long contending_point[LOCKSTAT_POINTS ];#endif -}; +} __no_randomize_layout;#ifdef CONFIG_LOCK_STAT struct lock_time {
kernel/locking/lockdep.c +348 -48
558 lines not on this page · raw message
PATCH v7 12/23 locking/lockdep: Reuse list entries that are no longer in use
In reply to Bart Van AsscheInstead of abandoning elements of list_entries[] that are no longer in use, make alloc_list_entry() reuse array elements that have been freed.
--- kernel/locking/lockdep.c | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-)
kernel/locking/lockdep.c +16 -8
@@ -45,6 +45,7 @@#include <linux/hash.h> #include <linux/ftrace.h> #include <linux/stringify.h> +#include <linux/bitmap.h> #include <linux/bitops.h> #include <linux/gfp.h> #include <linux/random.h>
@@ -132,6 +133,7 @@ static inline int debug_locks_off_graph_unlock(void)unsigned long nr_list_entries;static struct lock_list list_entries[MAX_LOCKDEP_ENTRIES ]; +static DECLARE_BITMAP(list_entries_in_use, MAX_LOCKDEP_ENTRIES);/* * All data structures here are protected by the global debug_lock.
@@ -907,7 +909,10 @@ register_lock_class(struct lockdep_map *lock, unsigned int subclass, int force)*/ static struct lock_list *alloc_list_entry (void ) { -if (nr_list_entries >=MAX_LOCKDEP_ENTRIES ) { +int idx =find_first_zero_bit (list_entries_in_use, +ARRAY_SIZE (list_entries)); + +if (idx >=ARRAY_SIZE (list_entries)) {if (!debug_locks_off_graph_unlock ())return NULL ;
@@ -915,7 +920,9 @@ static struct lock_list *alloc_list_entry(void)dump_stack ();return NULL ; } -return list_entries + nr_list_entries++; + nr_list_entries++; +__set_bit (idx, list_entries_in_use); +return list_entries + idx; }/*
@@ -1019,7 +1026,7 @@ static inline void mark_lock_accessed(struct lock_list *lock,unsigned long nr; nr = lock - list_entries; -WARN_ON (nr >= nr_list_entries);/* Out-of-bounds, input fail */ +WARN_ON (nr >=ARRAY_SIZE (list_entries));/* Out-of-bounds, input fail */ lock->parent = parent; lock->class->dep_gen_id = lockdep_dependency_gen_id; }
@@ -1029,7 +1036,7 @@ static inline unsigned long lock_accessed(struct lock_list *lock)unsigned long nr; nr = lock - list_entries; -WARN_ON (nr >= nr_list_entries);/* Out-of-bounds, input fail */ +WARN_ON (nr >=ARRAY_SIZE (list_entries));/* Out-of-bounds, input fail */ return lock->class->dep_gen_id == lockdep_dependency_gen_id; }
@@ -4288,13 +4295,13 @@ static void zap_class(struct pending_free *pf, struct lock_class *class)* Remove all dependencies this lock is * involved in: */ -for (i =0 , entry = list_entries; i < nr_list_entries; i++, entry++) { +for_each_set_bit (i, list_entries_in_use,ARRAY_SIZE (list_entries)) { + entry = list_entries + i;if (entry->class != class && entry->links_to != class)continue ; +__clear_bit (i, list_entries_in_use); + nr_list_entries--;list_del_rcu (&entry->entry); -/* Clear .class and .links_to to avoid double removal. */ -WRITE_ONCE (entry->class,NULL ); -WRITE_ONCE (entry->links_to,NULL ); }if (list_empty (&class->locks_after) &&list_empty (&class->locks_before)) {
@@ -4608,6 +4615,7 @@ void __init lockdep_init(void) (sizeof(lock_classes) + sizeof(classhash_table) + sizeof(list_entries) + + sizeof(list_entries_in_use) + sizeof(chainhash_table) + sizeof(delayed_free)#ifdef CONFIG_PROVE_LOCKING
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
tip-bot for Bart Van Assche
merge bot[tip:locking/core] locking/lockdep: Reuse list entries that are no longer in use
locking/lockdep: Reuse list entries that are no longer in use
Commit-ID: ace35a7ac493d4284a57ad807579011bebba891c Gitweb: https://git.kernel.org/tip/ace35a7ac493d4284a57ad807579011bebba891c Author: Bart Van Assche <[email protected]> AuthorDate: Thu, 14 Feb 2019 15:00:47 -0800 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 28 Feb 2019 07:55:44 +0100
locking/lockdep: Reuse list entries that are no longer in use
Instead of abandoning elements of list_entries[] that are no longer in use, make alloc_list_entry() reuse array elements that have been freed.
--- kernel/locking/lockdep.c | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-)
kernel/locking/lockdep.c +16 -8
@@ -45,6 +45,7 @@#include <linux/hash.h> #include <linux/ftrace.h> #include <linux/stringify.h> +#include <linux/bitmap.h> #include <linux/bitops.h> #include <linux/gfp.h> #include <linux/random.h>
@@ -132,6 +133,7 @@ static inline int debug_locks_off_graph_unlock(void)unsigned long nr_list_entries;static struct lock_list list_entries[MAX_LOCKDEP_ENTRIES ]; +static DECLARE_BITMAP(list_entries_in_use, MAX_LOCKDEP_ENTRIES);/* * All data structures here are protected by the global debug_lock.
@@ -907,7 +909,10 @@ out_set_class_cache:*/ static struct lock_list *alloc_list_entry (void ) { -if (nr_list_entries >=MAX_LOCKDEP_ENTRIES ) { +int idx =find_first_zero_bit (list_entries_in_use, +ARRAY_SIZE (list_entries)); + +if (idx >=ARRAY_SIZE (list_entries)) {if (!debug_locks_off_graph_unlock ())return NULL ;
@@ -915,7 +920,9 @@ static struct lock_list *alloc_list_entry(void)dump_stack ();return NULL ; } -return list_entries + nr_list_entries++; + nr_list_entries++; +__set_bit (idx, list_entries_in_use); +return list_entries + idx; }/*
@@ -1019,7 +1026,7 @@ static inline void mark_lock_accessed(struct lock_list *lock,unsigned long nr; nr = lock - list_entries; -WARN_ON (nr >= nr_list_entries);/* Out-of-bounds, input fail */ +WARN_ON (nr >=ARRAY_SIZE (list_entries));/* Out-of-bounds, input fail */ lock->parent = parent; lock->class->dep_gen_id = lockdep_dependency_gen_id; }
@@ -1029,7 +1036,7 @@ static inline unsigned long lock_accessed(struct lock_list *lock)unsigned long nr; nr = lock - list_entries; -WARN_ON (nr >= nr_list_entries);/* Out-of-bounds, input fail */ +WARN_ON (nr >=ARRAY_SIZE (list_entries));/* Out-of-bounds, input fail */ return lock->class->dep_gen_id == lockdep_dependency_gen_id; }
@@ -4276,13 +4283,13 @@ static void zap_class(struct pending_free *pf, struct lock_class *class)* Remove all dependencies this lock is * involved in: */ -for (i =0 , entry = list_entries; i < nr_list_entries; i++, entry++) { +for_each_set_bit (i, list_entries_in_use,ARRAY_SIZE (list_entries)) { + entry = list_entries + i;if (entry->class != class && entry->links_to != class)continue ; +__clear_bit (i, list_entries_in_use); + nr_list_entries--;list_del_rcu (&entry->entry); -/* Clear .class and .links_to to avoid double removal. */ -WRITE_ONCE (entry->class,NULL ); -WRITE_ONCE (entry->links_to,NULL ); }if (list_empty (&class->locks_after) &&list_empty (&class->locks_before)) {
@@ -4596,6 +4603,7 @@ void __init lockdep_init(void) (sizeof(lock_classes) + sizeof(classhash_table) + sizeof(list_entries) + + sizeof(list_entries_in_use) + sizeof(chainhash_table) + sizeof(delayed_free)#ifdef CONFIG_PROVE_LOCKING
PATCH v7 13/23 locking/lockdep: Introduce lockdep_next_lockchain() and lock_chain_count()
In reply to Bart Van AsscheThis patch does not change any functionality but makes the next patch in this series easier to read.
--- kernel/locking/lockdep.c | 16 +++++++++++++++- kernel/locking/lockdep_internals.h | 3 ++- kernel/locking/lockdep_proc.c | 12 ++++++------ 3 files changed, 23 insertions(+), 8 deletions(-)
kernel/locking/lockdep.c +15 -1
@@ -2107,7 +2107,7 @@ check_prevs_add(struct task_struct *curr, struct held_lock *next)return 0 ; } -unsigned long nr_lock_chains; +static unsigned long nr_lock_chains;struct lock_chain lock_chains[MAX_LOCKDEP_CHAINS ];int nr_chain_hlocks;static u16 chain_hlocks[MAX_LOCKDEP_CHAIN_HLOCKS ];
@@ -2241,6 +2241,20 @@ static int check_no_collision(struct task_struct *curr,return 1 ; } +/* +* Given an index that is >= -1, return the index of the next lock chain. +* Return -2 if there is no next lock chain. +*/ +long lockdep_next_lockchain (long i) +{ +return i +1 < nr_lock_chains ? i +1 :-2 ; +} + +unsigned long lock_chain_count (void ) +{ +return nr_lock_chains; +} +/* * Adds a dependency chain into chain hashtable. And must be called with * graph_lock held.
kernel/locking/lockdep_internals.h +2 -1
@@ -96,7 +96,8 @@ struct lock_class *lock_chain_get_class(struct lock_chain *chain, int i);extern unsigned long nr_lock_classes;extern unsigned long nr_list_entries; -extern unsigned long nr_lock_chains; +long lockdep_next_lockchain (long i); +unsigned long lock_chain_count (void );extern int nr_chain_hlocks;extern unsigned long nr_stack_trace_entries;
kernel/locking/lockdep_proc.c +6 -6
@@ -104,18 +104,18 @@ static const struct seq_operations lockdep_ops = {#ifdef CONFIG_PROVE_LOCKING static void *lc_start (struct seq_file *m,loff_t *pos) { +if (*pos <0 ) +return NULL ; +if (*pos ==0 )return SEQ_START_TOKEN ; -if (*pos -1 < nr_lock_chains) -return lock_chains + (*pos -1 ); - -return NULL ; +return lock_chains + (*pos -1 ); }static void *lc_next (struct seq_file *m,void *v,loff_t *pos) { - (*pos)++; + *pos =lockdep_next_lockchain (*pos -1 ) +1 ;return lc_start (m, pos); }
@@ -268,7 +268,7 @@ static int lockdep_stats_show(struct seq_file *m, void *v)#ifdef CONFIG_PROVE_LOCKING seq_printf (m," dependency chains: %11lu [max: %lu]\n" , - nr_lock_chains,MAX_LOCKDEP_CHAINS ); +lock_chain_count (),MAX_LOCKDEP_CHAINS );seq_printf (m," dependency chain hlocks: %11d [max: %lu]\n" , nr_chain_hlocks,MAX_LOCKDEP_CHAIN_HLOCKS );#endif
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
tip-bot for Bart Van Assche
merge bot[tip:locking/core] locking/lockdep: Introduce lockdep_next_lockchain() and lock_chain_count()
locking/lockdep: Introduce lockdep_next_lockchain() and lock_chain_count()
Commit-ID: 2212684adff79e2704a2792ff46682afb9246fc8 Gitweb: https://git.kernel.org/tip/2212684adff79e2704a2792ff46682afb9246fc8 Author: Bart Van Assche <[email protected]> AuthorDate: Thu, 14 Feb 2019 15:00:48 -0800 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 28 Feb 2019 07:55:44 +0100
locking/lockdep: Introduce lockdep_next_lockchain() and lock_chain_count()
This patch does not change any functionality but makes the next patch in this series easier to read.
--- kernel/locking/lockdep.c | 16 +++++++++++++++- kernel/locking/lockdep_internals.h | 3 ++- kernel/locking/lockdep_proc.c | 12 ++++++------ 3 files changed, 23 insertions(+), 8 deletions(-)
kernel/locking/lockdep.c +15 -1
@@ -2096,7 +2096,7 @@ out_bug:return 0 ; } -unsigned long nr_lock_chains; +static unsigned long nr_lock_chains;struct lock_chain lock_chains[MAX_LOCKDEP_CHAINS ];int nr_chain_hlocks;static u16 chain_hlocks[MAX_LOCKDEP_CHAIN_HLOCKS ];
@@ -2230,6 +2230,20 @@ static int check_no_collision(struct task_struct *curr,return 1 ; } +/* +* Given an index that is >= -1, return the index of the next lock chain. +* Return -2 if there is no next lock chain. +*/ +long lockdep_next_lockchain (long i) +{ +return i +1 < nr_lock_chains ? i +1 :-2 ; +} + +unsigned long lock_chain_count (void ) +{ +return nr_lock_chains; +} +/* * Adds a dependency chain into chain hashtable. And must be called with * graph_lock held.
kernel/locking/lockdep_internals.h +2 -1
@@ -100,7 +100,8 @@ struct lock_class *lock_chain_get_class(struct lock_chain *chain, int i);extern unsigned long nr_lock_classes;extern unsigned long nr_list_entries; -extern unsigned long nr_lock_chains; +long lockdep_next_lockchain (long i); +unsigned long lock_chain_count (void );extern int nr_chain_hlocks;extern unsigned long nr_stack_trace_entries;
kernel/locking/lockdep_proc.c +6 -6
@@ -104,18 +104,18 @@ static const struct seq_operations lockdep_ops = {#ifdef CONFIG_PROVE_LOCKING static void *lc_start (struct seq_file *m,loff_t *pos) { +if (*pos <0 ) +return NULL ; +if (*pos ==0 )return SEQ_START_TOKEN ; -if (*pos -1 < nr_lock_chains) -return lock_chains + (*pos -1 ); - -return NULL ; +return lock_chains + (*pos -1 ); }static void *lc_next (struct seq_file *m,void *v,loff_t *pos) { - (*pos)++; + *pos =lockdep_next_lockchain (*pos -1 ) +1 ;return lc_start (m, pos); }
@@ -268,7 +268,7 @@ static int lockdep_stats_show(struct seq_file *m, void *v)#ifdef CONFIG_PROVE_LOCKING seq_printf (m," dependency chains: %11lu [max: %lu]\n" , - nr_lock_chains,MAX_LOCKDEP_CHAINS ); +lock_chain_count (),MAX_LOCKDEP_CHAINS );seq_printf (m," dependency chain hlocks: %11d [max: %lu]\n" , nr_chain_hlocks,MAX_LOCKDEP_CHAIN_HLOCKS );#endif
PATCH v7 14/23 locking/lockdep: Fix a comment in add_chain_cache()
In reply to Bart Van AsscheReflect that add_chain_cache() is always called with the graph lock held.
--- kernel/locking/lockdep.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/locking/lockdep.c +1 -1
@@ -2277,7 +2277,7 @@ static inline int add_chain_cache(struct task_struct *curr,*/ /* -* We might need to take the graph lock, ensure we've got IRQs +* The caller must hold the graph lock, ensure we've got IRQs * disabled to make this an IRQ-safe lock.. for recursion reasons * lockdep won't complain about its own locking errors. */
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
tip-bot for Bart Van Assche
merge bot[tip:locking/core] locking/lockdep: Fix a comment in add_chain_cache()
locking/lockdep: Fix a comment in add_chain_cache()
Commit-ID: 527af3ea273b2cf0c017a2c90090b3c94af8aba4 Gitweb: https://git.kernel.org/tip/527af3ea273b2cf0c017a2c90090b3c94af8aba4 Author: Bart Van Assche <[email protected]> AuthorDate: Thu, 14 Feb 2019 15:00:49 -0800 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 28 Feb 2019 07:55:45 +0100
locking/lockdep: Fix a comment in add_chain_cache()
Reflect that add_chain_cache() is always called with the graph lock held.
--- kernel/locking/lockdep.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/locking/lockdep.c +1 -1
@@ -2266,7 +2266,7 @@ static inline int add_chain_cache(struct task_struct *curr,*/ /* -* We might need to take the graph lock, ensure we've got IRQs +* The caller must hold the graph lock, ensure we've got IRQs * disabled to make this an IRQ-safe lock.. for recursion reasons * lockdep won't complain about its own locking errors. */
PATCH v7 15/23 locking/lockdep: Reuse lock chains that have been freed
In reply to Bart Van AsscheA previous patch introduced a lock chain leak. Fix that leak by reusing lock chains that have been freed.
--- kernel/locking/lockdep.c | 57 ++++++++++++++++++++++++++-------------- 1 file changed, 37 insertions(+), 20 deletions(-)
kernel/locking/lockdep.c +37 -20
@@ -292,9 +292,12 @@ static LIST_HEAD(free_lock_classes);/** * struct pending_free - information about data structures about to be freed * @zapped: Head of a list with struct lock_class elements. +* @lock_chains_being_freed: Bitmap that indicates which lock_chains[] elements +* are about to be freed. */ struct pending_free {struct list_head zapped; + DECLARE_BITMAP(lock_chains_being_freed, MAX_LOCKDEP_CHAINS); };/**
@@ -2107,8 +2110,8 @@ check_prevs_add(struct task_struct *curr, struct held_lock *next)return 0 ; } -static unsigned long nr_lock_chains;struct lock_chain lock_chains[MAX_LOCKDEP_CHAINS ]; +static DECLARE_BITMAP(lock_chains_in_use, MAX_LOCKDEP_CHAINS);int nr_chain_hlocks;static u16 chain_hlocks[MAX_LOCKDEP_CHAIN_HLOCKS ];
@@ -2247,12 +2250,25 @@ static int check_no_collision(struct task_struct *curr,*/ long lockdep_next_lockchain (long i) { -return i +1 < nr_lock_chains ? i +1 :-2 ; + i =find_next_bit (lock_chains_in_use,ARRAY_SIZE (lock_chains), i +1 ); +return i <ARRAY_SIZE (lock_chains) ? i :-2 ; }unsigned long lock_chain_count (void ) { -return nr_lock_chains; +return bitmap_weight (lock_chains_in_use,ARRAY_SIZE (lock_chains)); +} + +/* Must be called with the graph lock held. */ +static struct lock_chain *alloc_lock_chain (void ) +{ +int idx =find_first_zero_bit (lock_chains_in_use, +ARRAY_SIZE (lock_chains)); + +if (unlikely (idx >=ARRAY_SIZE (lock_chains))) +return NULL ; +__set_bit (idx, lock_chains_in_use); +return lock_chains + idx; }/*
@@ -2271,11 +2287,6 @@ static inline int add_chain_cache(struct task_struct *curr,struct lock_chain *chain;int i, j; -/* -* Allocate a new chain entry from the static array, and add -* it to the hash: -*/ -/* * The caller must hold the graph lock, ensure we've got IRQs * disabled to make this an IRQ-safe lock.. for recursion reasons
@@ -2284,7 +2295,8 @@ static inline int add_chain_cache(struct task_struct *curr,if (DEBUG_LOCKS_WARN_ON (!irqs_disabled ()))return 0 ; -if (unlikely (nr_lock_chains >=MAX_LOCKDEP_CHAINS )) { + chain =alloc_lock_chain (); +if (!chain) {if (!debug_locks_off_graph_unlock ())return 0 ;
@@ -2292,7 +2304,6 @@ static inline int add_chain_cache(struct task_struct *curr,dump_stack ();return 0 ; } - chain = lock_chains + nr_lock_chains++; chain->chain_key = chain_key; chain->irq_context = hlock->irq_context; i =get_first_held_lock (curr, hlock);
@@ -4220,7 +4231,8 @@ void lockdep_reset(void) }/* Remove a class from a lock chain. Must be called with the graph lock held. */ -static void remove_class_from_lock_chain (struct lock_chain *chain, +static void remove_class_from_lock_chain (struct pending_free *pf, +struct lock_chain *chain,struct lock_class *class) {#ifdef CONFIG_PROVE_LOCKING
@@ -4258,6 +4270,7 @@ static void remove_class_from_lock_chain(struct lock_chain *chain,* hlist_for_each_entry_rcu() loop is safe. */ hlist_del_rcu (&chain->entry); +__set_bit (chain - lock_chains, pf->lock_chains_being_freed);if (chain->depth ==0 )return ;/*
@@ -4266,22 +4279,19 @@ static void remove_class_from_lock_chain(struct lock_chain *chain,*/ if (lookup_chain_cache (chain_key))return ; -if (WARN_ON_ONCE (nr_lock_chains >=MAX_LOCKDEP_CHAINS )) { + new_chain =alloc_lock_chain (); +if (WARN_ON_ONCE (!new_chain)) {debug_locks_off ();return ; } -/* -* Leak *chain because it is not safe to reinsert it before an RCU -* grace period has expired. -*/ - new_chain = lock_chains + nr_lock_chains++; *new_chain = *chain;hlist_add_head_rcu (&new_chain->entry,chainhashentry (chain_key));#endif }/* Must be called with the graph lock held. */ -static void remove_class_from_lock_chains (struct lock_class *class) +static void remove_class_from_lock_chains (struct pending_free *pf, +struct lock_class *class) {struct lock_chain *chain;struct hlist_head *head;
@@ -4290,7 +4300,7 @@ static void remove_class_from_lock_chains(struct lock_class *class)for (i =0 ; i <ARRAY_SIZE (chainhash_table); i++) { head = chainhash_table + i;hlist_for_each_entry_rcu (chain, head, entry) { -remove_class_from_lock_chain (chain, class); +remove_class_from_lock_chain (pf, chain, class); } } }
@@ -4329,7 +4339,7 @@ static void zap_class(struct pending_free *pf, struct lock_class *class) class->name); } -remove_class_from_lock_chains (class); +remove_class_from_lock_chains (pf, class); }static void reinit_class (struct lock_class *class)
@@ -4395,6 +4405,12 @@ static void __free_zapped_classes(struct pending_free *pf)reinit_class (class);list_splice_init (&pf->zapped, &free_lock_classes); + +#ifdef CONFIG_PROVE_LOCKING +bitmap_andnot (lock_chains_in_use, lock_chains_in_use, + pf->lock_chains_being_freed,ARRAY_SIZE (lock_chains)); +bitmap_clear (pf->lock_chains_being_freed,0 ,ARRAY_SIZE (lock_chains)); +#endif }static void free_zapped_rcu (struct rcu_head *ch)
@@ -4635,6 +4651,7 @@ void __init lockdep_init(void)#ifdef CONFIG_PROVE_LOCKING +sizeof (lock_cq) +sizeof (lock_chains) + +sizeof (lock_chains_in_use) +sizeof (chain_hlocks) #endif ) / 1024
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
tip-bot for Bart Van Assche
merge bot[tip:locking/core] locking/lockdep: Reuse lock chains that have been freed
locking/lockdep: Reuse lock chains that have been freed
Commit-ID: de4643a77356a77bce73f64275b125b4b71a69cf Gitweb: https://git.kernel.org/tip/de4643a77356a77bce73f64275b125b4b71a69cf Author: Bart Van Assche <[email protected]> AuthorDate: Thu, 14 Feb 2019 15:00:50 -0800 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 28 Feb 2019 07:55:45 +0100
locking/lockdep: Reuse lock chains that have been freed
A previous patch introduced a lock chain leak. Fix that leak by reusing lock chains that have been freed.
--- kernel/locking/lockdep.c | 57 +++++++++++++++++++++++++++++++----------------- 1 file changed, 37 insertions(+), 20 deletions(-)
kernel/locking/lockdep.c +37 -20
@@ -292,9 +292,12 @@ static LIST_HEAD(free_lock_classes);/** * struct pending_free - information about data structures about to be freed * @zapped: Head of a list with struct lock_class elements. +* @lock_chains_being_freed: Bitmap that indicates which lock_chains[] elements +* are about to be freed. */ struct pending_free {struct list_head zapped; + DECLARE_BITMAP(lock_chains_being_freed, MAX_LOCKDEP_CHAINS); };/**
@@ -2096,8 +2099,8 @@ out_bug:return 0 ; } -static unsigned long nr_lock_chains;struct lock_chain lock_chains[MAX_LOCKDEP_CHAINS ]; +static DECLARE_BITMAP(lock_chains_in_use, MAX_LOCKDEP_CHAINS);int nr_chain_hlocks;static u16 chain_hlocks[MAX_LOCKDEP_CHAIN_HLOCKS ];
@@ -2236,12 +2239,25 @@ static int check_no_collision(struct task_struct *curr,*/ long lockdep_next_lockchain (long i) { -return i +1 < nr_lock_chains ? i +1 :-2 ; + i =find_next_bit (lock_chains_in_use,ARRAY_SIZE (lock_chains), i +1 ); +return i <ARRAY_SIZE (lock_chains) ? i :-2 ; }unsigned long lock_chain_count (void ) { -return nr_lock_chains; +return bitmap_weight (lock_chains_in_use,ARRAY_SIZE (lock_chains)); +} + +/* Must be called with the graph lock held. */ +static struct lock_chain *alloc_lock_chain (void ) +{ +int idx =find_first_zero_bit (lock_chains_in_use, +ARRAY_SIZE (lock_chains)); + +if (unlikely (idx >=ARRAY_SIZE (lock_chains))) +return NULL ; +__set_bit (idx, lock_chains_in_use); +return lock_chains + idx; }/*
@@ -2260,11 +2276,6 @@ static inline int add_chain_cache(struct task_struct *curr,struct lock_chain *chain;int i, j; -/* -* Allocate a new chain entry from the static array, and add -* it to the hash: -*/ -/* * The caller must hold the graph lock, ensure we've got IRQs * disabled to make this an IRQ-safe lock.. for recursion reasons
@@ -2273,7 +2284,8 @@ static inline int add_chain_cache(struct task_struct *curr,if (DEBUG_LOCKS_WARN_ON (!irqs_disabled ()))return 0 ; -if (unlikely (nr_lock_chains >=MAX_LOCKDEP_CHAINS )) { + chain =alloc_lock_chain (); +if (!chain) {if (!debug_locks_off_graph_unlock ())return 0 ;
@@ -2281,7 +2293,6 @@ static inline int add_chain_cache(struct task_struct *curr,dump_stack ();return 0 ; } - chain = lock_chains + nr_lock_chains++; chain->chain_key = chain_key; chain->irq_context = hlock->irq_context; i =get_first_held_lock (curr, hlock);
@@ -4208,7 +4219,8 @@ void lockdep_reset(void) }/* Remove a class from a lock chain. Must be called with the graph lock held. */ -static void remove_class_from_lock_chain (struct lock_chain *chain, +static void remove_class_from_lock_chain (struct pending_free *pf, +struct lock_chain *chain,struct lock_class *class) {#ifdef CONFIG_PROVE_LOCKING
@@ -4246,6 +4258,7 @@ recalc:* hlist_for_each_entry_rcu() loop is safe. */ hlist_del_rcu (&chain->entry); +__set_bit (chain - lock_chains, pf->lock_chains_being_freed);if (chain->depth ==0 )return ;/*
@@ -4254,22 +4267,19 @@ recalc:*/ if (lookup_chain_cache (chain_key))return ; -if (WARN_ON_ONCE (nr_lock_chains >=MAX_LOCKDEP_CHAINS )) { + new_chain =alloc_lock_chain (); +if (WARN_ON_ONCE (!new_chain)) {debug_locks_off ();return ; } -/* -* Leak *chain because it is not safe to reinsert it before an RCU -* grace period has expired. -*/ - new_chain = lock_chains + nr_lock_chains++; *new_chain = *chain;hlist_add_head_rcu (&new_chain->entry,chainhashentry (chain_key));#endif }/* Must be called with the graph lock held. */ -static void remove_class_from_lock_chains (struct lock_class *class) +static void remove_class_from_lock_chains (struct pending_free *pf, +struct lock_class *class) {struct lock_chain *chain;struct hlist_head *head;
@@ -4278,7 +4288,7 @@ static void remove_class_from_lock_chains(struct lock_class *class)for (i =0 ; i <ARRAY_SIZE (chainhash_table); i++) { head = chainhash_table + i;hlist_for_each_entry_rcu (chain, head, entry) { -remove_class_from_lock_chain (chain, class); +remove_class_from_lock_chain (pf, chain, class); } } }
@@ -4317,7 +4327,7 @@ static void zap_class(struct pending_free *pf, struct lock_class *class) class->name); } -remove_class_from_lock_chains (class); +remove_class_from_lock_chains (pf, class); }static void reinit_class (struct lock_class *class)
@@ -4383,6 +4393,12 @@ static void __free_zapped_classes(struct pending_free *pf)reinit_class (class);list_splice_init (&pf->zapped, &free_lock_classes); + +#ifdef CONFIG_PROVE_LOCKING +bitmap_andnot (lock_chains_in_use, lock_chains_in_use, + pf->lock_chains_being_freed,ARRAY_SIZE (lock_chains)); +bitmap_clear (pf->lock_chains_being_freed,0 ,ARRAY_SIZE (lock_chains)); +#endif }static void free_zapped_rcu (struct rcu_head *ch)
@@ -4623,6 +4639,7 @@ void __init lockdep_init(void)#ifdef CONFIG_PROVE_LOCKING +sizeof (lock_cq) +sizeof (lock_chains) + +sizeof (lock_chains_in_use) +sizeof (chain_hlocks) #endif ) / 1024
PATCH v7 16/23 locking/lockdep: Check data structure consistency
In reply to Bart Van AsscheDebugging lockdep data structure inconsistencies is challenging. Add code that verifies data structure consistency at runtime. That code is disabled by default because it is very CPU intensive.
--- kernel/locking/lockdep.c | 167 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 167 insertions(+)
kernel/locking/lockdep.c +167 -0
@@ -74,6 +74,8 @@ module_param(lock_stat, int, 0644);#define lock_stat 0#endif +static bool check_data_structure_consistency; +/* * lockdep_lock: protects the lockdep graph, the hashes and the * class/list/hash allocators.
@@ -775,6 +777,168 @@ static bool assign_lock_key(struct lockdep_map *lock)return true; } +/* Check whether element @e occurs in list @h */ +static bool in_list (struct list_head *e,struct list_head *h) +{ +struct list_head *f; + +list_for_each (f, h) { +if (e == f) +return true; + } + +return false; +} + +/* +* Check whether entry @e occurs in any of the locks_after or locks_before +* lists. +*/ +static bool in_any_class_list (struct list_head *e) +{ +struct lock_class *class; +int i; + +for (i =0 ; i <ARRAY_SIZE (lock_classes); i++) { + class = &lock_classes[i]; +if (in_list (e, &class->locks_after) || +in_list (e, &class->locks_before)) +return true; + } +return false; +} + +static bool class_lock_list_valid (struct lock_class *c,struct list_head *h) +{ +struct lock_list *e; + +list_for_each_entry (e, h, entry) { +if (e->links_to != c) { +printk (KERN_INFO "class %s: mismatch for lock entry %ld; class %s <> %s" , + c->name ? :"(?)" , + (unsigned long )(e - list_entries), + e->links_to && e->links_to->name ? + e->links_to->name :"(?)" , + e->class && e->class->name ? e->class->name : +"(?)" ); +return false; + } + } +return true; +} + +static u16 chain_hlocks[]; + +static bool check_lock_chain_key (struct lock_chain *chain) +{ +#ifdef CONFIG_PROVE_LOCKING +u64 chain_key =0 ; +int i; + +for (i = chain->base; i < chain->base + chain->depth; i++) + chain_key =iterate_chain_key (chain_key, chain_hlocks[i] +1 ); +/* +* The 'unsigned long long' casts avoid that a compiler warning +* is reported when building tools/lib/lockdep. +*/ +if (chain->chain_key != chain_key) +printk (KERN_INFO "chain %lld: key %#llx <> %#llx\n" , + (unsigned long long )(chain - lock_chains), + (unsigned long long )chain->chain_key, + (unsigned long long )chain_key); +return chain->chain_key == chain_key; +#else +return true; +#endif +} + +static bool in_any_zapped_class_list (struct lock_class *class) +{ +struct pending_free *pf; +int i; + +for (i =0 , pf = delayed_free.pf; i <ARRAY_SIZE (delayed_free.pf); + i++, pf++) +if (in_list (&class->lock_entry, &pf->zapped)) +return true; + +return false; +} + +static bool check_data_structures (void ) +{ +struct lock_class *class; +struct lock_chain *chain; +struct hlist_head *head; +struct lock_list *e; +int i; + +/* Check whether all classes occur in a lock list. */ +for (i =0 ; i <ARRAY_SIZE (lock_classes); i++) { + class = &lock_classes[i]; +if (!in_list (&class->lock_entry, &all_lock_classes) && + !in_list (&class->lock_entry, &free_lock_classes) && + !in_any_zapped_class_list (class)) { +printk (KERN_INFO "class %px/%s is not in any class list\n" , + class, class->name ? :"(?)" ); +return false; +return false; + } + } + +/* Check whether all classes have valid lock lists. */ +for (i =0 ; i <ARRAY_SIZE (lock_classes); i++) { + class = &lock_classes[i]; +if (!class_lock_list_valid (class, &class->locks_before)) +return false; +if (!class_lock_list_valid (class, &class->locks_after)) +return false; + } + +/* Check the chain_key of all lock chains. */ +for (i =0 ; i <ARRAY_SIZE (chainhash_table); i++) { + head = chainhash_table + i; +hlist_for_each_entry_rcu (chain, head, entry) { +if (!check_lock_chain_key (chain)) +return false; + } + } + +/* +* Check whether all list entries that are in use occur in a class +* lock list. +*/ +for_each_set_bit (i, list_entries_in_use,ARRAY_SIZE (list_entries)) { + e = list_entries + i; +if (!in_any_class_list (&e->entry)) { +printk (KERN_INFO "list entry %d is not in any class list; class %s <> %s\n" , + (unsigned int )(e - list_entries), + e->class->name ? :"(?)" , + e->links_to->name ? :"(?)" ); +return false; + } + } + +/* +* Check whether all list entries that are not in use do not occur in +* a class lock list. +*/ +for_each_clear_bit (i, list_entries_in_use,ARRAY_SIZE (list_entries)) { + e = list_entries + i; +if (in_any_class_list (&e->entry)) { +printk (KERN_INFO "list entry %d occurs in a class list; class %s <> %s\n" , + (unsigned int )(e - list_entries), + e->class && e->class->name ? e->class->name : +"(?)" , + e->links_to && e->links_to->name ? + e->links_to->name :"(?)" ); +return false; + } + } + +return true; +} +/* * Initialize the lock_classes[] array elements, the free_lock_classes list * and also the delayed_free structure.
@@ -4401,6 +4565,9 @@ static void __free_zapped_classes(struct pending_free *pf) {struct lock_class *class; +if (check_data_structure_consistency) +WARN_ON_ONCE (!check_data_structures ()); +list_for_each_entry (class, &pf->zapped, lock_entry)reinit_class (class);
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
tip-bot for Bart Van Assche
merge bot[tip:locking/core] locking/lockdep: Check data structure consistency
locking/lockdep: Check data structure consistency
Commit-ID: b526b2e39a53b312f5a6867ce57824247aa0ce8b Gitweb: https://git.kernel.org/tip/b526b2e39a53b312f5a6867ce57824247aa0ce8b Author: Bart Van Assche <[email protected]> AuthorDate: Thu, 14 Feb 2019 15:00:51 -0800 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 28 Feb 2019 07:55:45 +0100
locking/lockdep: Check data structure consistency
Debugging lockdep data structure inconsistencies is challenging. Add code that verifies data structure consistency at runtime. That code is disabled by default because it is very CPU intensive.
--- kernel/locking/lockdep.c | 167 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 167 insertions(+)
kernel/locking/lockdep.c +167 -0
@@ -74,6 +74,8 @@ module_param(lock_stat, int, 0644);#define lock_stat 0#endif +static bool check_data_structure_consistency; +/* * lockdep_lock: protects the lockdep graph, the hashes and the * class/list/hash allocators.
@@ -775,6 +777,168 @@ static bool assign_lock_key(struct lockdep_map *lock)return true; } +/* Check whether element @e occurs in list @h */ +static bool in_list (struct list_head *e,struct list_head *h) +{ +struct list_head *f; + +list_for_each (f, h) { +if (e == f) +return true; + } + +return false; +} + +/* +* Check whether entry @e occurs in any of the locks_after or locks_before +* lists. +*/ +static bool in_any_class_list (struct list_head *e) +{ +struct lock_class *class; +int i; + +for (i =0 ; i <ARRAY_SIZE (lock_classes); i++) { + class = &lock_classes[i]; +if (in_list (e, &class->locks_after) || +in_list (e, &class->locks_before)) +return true; + } +return false; +} + +static bool class_lock_list_valid (struct lock_class *c,struct list_head *h) +{ +struct lock_list *e; + +list_for_each_entry (e, h, entry) { +if (e->links_to != c) { +printk (KERN_INFO "class %s: mismatch for lock entry %ld; class %s <> %s" , + c->name ? :"(?)" , + (unsigned long )(e - list_entries), + e->links_to && e->links_to->name ? + e->links_to->name :"(?)" , + e->class && e->class->name ? e->class->name : +"(?)" ); +return false; + } + } +return true; +} + +static u16 chain_hlocks[]; + +static bool check_lock_chain_key (struct lock_chain *chain) +{ +#ifdef CONFIG_PROVE_LOCKING +u64 chain_key =0 ; +int i; + +for (i = chain->base; i < chain->base + chain->depth; i++) + chain_key =iterate_chain_key (chain_key, chain_hlocks[i] +1 ); +/* +* The 'unsigned long long' casts avoid that a compiler warning +* is reported when building tools/lib/lockdep. +*/ +if (chain->chain_key != chain_key) +printk (KERN_INFO "chain %lld: key %#llx <> %#llx\n" , + (unsigned long long )(chain - lock_chains), + (unsigned long long )chain->chain_key, + (unsigned long long )chain_key); +return chain->chain_key == chain_key; +#else +return true; +#endif +} + +static bool in_any_zapped_class_list (struct lock_class *class) +{ +struct pending_free *pf; +int i; + +for (i =0 , pf = delayed_free.pf; i <ARRAY_SIZE (delayed_free.pf); + i++, pf++) +if (in_list (&class->lock_entry, &pf->zapped)) +return true; + +return false; +} + +static bool check_data_structures (void ) +{ +struct lock_class *class; +struct lock_chain *chain; +struct hlist_head *head; +struct lock_list *e; +int i; + +/* Check whether all classes occur in a lock list. */ +for (i =0 ; i <ARRAY_SIZE (lock_classes); i++) { + class = &lock_classes[i]; +if (!in_list (&class->lock_entry, &all_lock_classes) && + !in_list (&class->lock_entry, &free_lock_classes) && + !in_any_zapped_class_list (class)) { +printk (KERN_INFO "class %px/%s is not in any class list\n" , + class, class->name ? :"(?)" ); +return false; +return false; + } + } + +/* Check whether all classes have valid lock lists. */ +for (i =0 ; i <ARRAY_SIZE (lock_classes); i++) { + class = &lock_classes[i]; +if (!class_lock_list_valid (class, &class->locks_before)) +return false; +if (!class_lock_list_valid (class, &class->locks_after)) +return false; + } + +/* Check the chain_key of all lock chains. */ +for (i =0 ; i <ARRAY_SIZE (chainhash_table); i++) { + head = chainhash_table + i; +hlist_for_each_entry_rcu (chain, head, entry) { +if (!check_lock_chain_key (chain)) +return false; + } + } + +/* +* Check whether all list entries that are in use occur in a class +* lock list. +*/ +for_each_set_bit (i, list_entries_in_use,ARRAY_SIZE (list_entries)) { + e = list_entries + i; +if (!in_any_class_list (&e->entry)) { +printk (KERN_INFO "list entry %d is not in any class list; class %s <> %s\n" , + (unsigned int )(e - list_entries), + e->class->name ? :"(?)" , + e->links_to->name ? :"(?)" ); +return false; + } + } + +/* +* Check whether all list entries that are not in use do not occur in +* a class lock list. +*/ +for_each_clear_bit (i, list_entries_in_use,ARRAY_SIZE (list_entries)) { + e = list_entries + i; +if (in_any_class_list (&e->entry)) { +printk (KERN_INFO "list entry %d occurs in a class list; class %s <> %s\n" , + (unsigned int )(e - list_entries), + e->class && e->class->name ? e->class->name : +"(?)" , + e->links_to && e->links_to->name ? + e->links_to->name :"(?)" ); +return false; + } + } + +return true; +} +/* * Initialize the lock_classes[] array elements, the free_lock_classes list * and also the delayed_free structure.
@@ -4389,6 +4553,9 @@ static void __free_zapped_classes(struct pending_free *pf) {struct lock_class *class; +if (check_data_structure_consistency) +WARN_ON_ONCE (!check_data_structures ()); +list_for_each_entry (class, &pf->zapped, lock_entry)reinit_class (class);
PATCH v7 17/23 locking/lockdep: Verify whether lock objects are small enough to be used as class keys
In reply to Bart Van Assche--- kernel/locking/lockdep.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
kernel/locking/lockdep.c +11 -0
@@ -758,6 +758,17 @@ static bool assign_lock_key(struct lockdep_map *lock) {unsigned long can_addr, addr = (unsigned long )lock; +#ifdef __KERNEL__ +/* +* lockdep_free_key_range() assumes that struct lock_class_key +* objects do not overlap. Since we use the address of lock +* objects as class key for static objects, check whether the +* size of lock_class_key objects does not exceed the size of +* the smallest lock object. +*/ +BUILD_BUG_ON (sizeof (struct lock_class_key ) >sizeof (raw_spinlock_t)); +#endif +if (__is_kernel_percpu_address (addr, &can_addr)) lock->key = (void *)can_addr;else if (__is_module_percpu_address (addr, &can_addr))
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
tip-bot for Bart Van Assche
merge bot[tip:locking/core] locking/lockdep: Verify whether lock objects are small enough to be used as class keys
locking/lockdep: Verify whether lock objects are small enough to be used as class keys
Commit-ID: 4bf508621855613ca2ac782f70c3171e0e8bb011 Gitweb: https://git.kernel.org/tip/4bf508621855613ca2ac782f70c3171e0e8bb011 Author: Bart Van Assche <[email protected]> AuthorDate: Thu, 14 Feb 2019 15:00:52 -0800 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 28 Feb 2019 07:55:46 +0100
locking/lockdep: Verify whether lock objects are small enough to be used as class keys
--- kernel/locking/lockdep.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
kernel/locking/lockdep.c +11 -0
@@ -758,6 +758,17 @@ static bool assign_lock_key(struct lockdep_map *lock) {unsigned long can_addr, addr = (unsigned long )lock; +#ifdef __KERNEL__ +/* +* lockdep_free_key_range() assumes that struct lock_class_key +* objects do not overlap. Since we use the address of lock +* objects as class key for static objects, check whether the +* size of lock_class_key objects does not exceed the size of +* the smallest lock object. +*/ +BUILD_BUG_ON (sizeof (struct lock_class_key ) >sizeof (raw_spinlock_t)); +#endif +if (__is_kernel_percpu_address (addr, &can_addr)) lock->key = (void *)can_addr;else if (__is_module_percpu_address (addr, &can_addr))
PATCH v7 18/23 locking/lockdep: Add support for dynamic keys
In reply to Bart Van AsscheA shortcoming of the current lockdep implementation is that it requires lock keys to be allocated statically. That forces all instances of lock objects that occur in a given data structure to share a lock key. Since lock dependency analysis groups lock objects per key sharing lock keys can cause false positive lockdep reports. Make it possible to avoid such false positive reports by allowing lock keys to be allocated dynamically. Require that dynamically allocated lock keys are registered before use by calling lockdep_register_key(). Complain about attempts to register the same lock key pointer twice without calling lockdep_unregister_key() between successive registration calls.
The purpose of the new lock_keys_hash[] data structure that keeps track of all dynamic keys is twofold:
- Verify whether the lockdep_register_key() and lockdep_unregister_key() functions are used correctly.
- Avoid that lockdep_init_map() complains when encountering a dynamically allocated key.
--- include/linux/lockdep.h | 21 ++++++- kernel/locking/lockdep.c | 122 ++++++++++++++++++++++++++++++++++++--- 2 files changed, 132 insertions(+), 11 deletions(-)
include/linux/lockdep.h +18 -3
@@ -46,15 +46,19 @@ extern int lock_stat;#define NR_LOCKDEP_CACHING_CLASSES 2/* -* Lock-classes are keyed via unique addresses, by embedding the -* lockclass-key into the kernel (or module) .data section. (For -* static locks we use the lock address itself as the key.) +* A lockdep key is associated with each lock object. For static locks we use +* the lock address itself as the key. Dynamically allocated lock objects can +* have a statically or dynamically allocated key. Dynamically allocated lock +* keys must be registered before being used and must be unregistered before +* the key memory is freed. */ struct lockdep_subclass_key {char __one_byte; } __attribute__ ((__packed__ )); +/* hash_entry is used to keep track of dynamically allocated keys. */ struct lock_class_key { +struct hlist_node hash_entry;struct lockdep_subclass_key subkeys[MAX_LOCKDEP_SUBCLASSES ]; };
@@ -273,6 +277,9 @@ extern void lockdep_set_selftest_task(struct task_struct *task);extern void lockdep_off (void );extern void lockdep_on (void ); +extern void lockdep_register_key (struct lock_class_key *key); +extern void lockdep_unregister_key (struct lock_class_key *key); +/* * These methods are used by specific locking variants (spinlocks, * rwlocks, mutexes and rwsems) to pass init/acquire/release events
@@ -434,6 +441,14 @@ static inline void lockdep_set_selftest_task(struct task_struct *task)*/ struct lock_class_key { }; +static inline void lockdep_register_key (struct lock_class_key *key) +{ +} + +static inline void lockdep_unregister_key (struct lock_class_key *key) +{ +} +/* * The lockdep_map takes no space if lockdep is disabled: */
kernel/locking/lockdep.c +114 -8
159 lines not on this page · raw message
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
Peter Zijlstra
maintainerinclude/linux/lockdep.h extern int lock_stat; · line 63
Quoted 5 lines · Bart Van Assche
include/linux/lockdep.h +2
-0+/* hash_entry is used to keep track of dynamically allocated keys. */ struct lock_class_key { +struct hlist_node hash_entry;struct lockdep_subclass_key subkeys[MAX_LOCKDEP_SUBCLASSES ]; };
I think we can make that:
struct lock_class_key {
union {
struct hlist_node hash_entry;
struct lockdep_subclass_key subkeys[MAX_LOCKDEP_SUBCLASSES];
};
};I've added a patch to that effect at the end. IIRC we never actually store anything in the subkeys, we just use the address.
tip-bot for Bart Van Assche
merge botlocking/lockdep: Add support for dynamic keys
Commit-ID: 108c14858b9ea224686e476c8f5ec345a0df9e27 Gitweb: https://git.kernel.org/tip/108c14858b9ea224686e476c8f5ec345a0df9e27 Author: Bart Van Assche <[email protected]> AuthorDate: Thu, 14 Feb 2019 15:00:53 -0800 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 28 Feb 2019 07:55:47 +0100
locking/lockdep: Add support for dynamic keys
A shortcoming of the current lockdep implementation is that it requires lock keys to be allocated statically. That forces all instances of lock objects that occur in a given data structure to share a lock key. Since lock dependency analysis groups lock objects per key sharing lock keys can cause false positive lockdep reports. Make it possible to avoid such false positive reports by allowing lock keys to be allocated dynamically. Require that dynamically allocated lock keys are registered before use by calling lockdep_register_key(). Complain about attempts to register the same lock key pointer twice without calling lockdep_unregister_key() between successive registration calls.
The purpose of the new lock_keys_hash[] data structure that keeps track of all dynamic keys is twofold:
- Verify whether the lockdep_register_key() and lockdep_unregister_key() functions are used correctly.
- Avoid that lockdep_init_map() complains when encountering a dynamically allocated key.
--- include/linux/lockdep.h | 21 ++++++-- kernel/locking/lockdep.c | 121 +++++++++++++++++++++++++++++++++++++++++++---- 2 files changed, 131 insertions(+), 11 deletions(-)
include/linux/lockdep.h +18 -3
@@ -46,15 +46,19 @@ extern int lock_stat;#define NR_LOCKDEP_CACHING_CLASSES 2/* -* Lock-classes are keyed via unique addresses, by embedding the -* lockclass-key into the kernel (or module) .data section. (For -* static locks we use the lock address itself as the key.) +* A lockdep key is associated with each lock object. For static locks we use +* the lock address itself as the key. Dynamically allocated lock objects can +* have a statically or dynamically allocated key. Dynamically allocated lock +* keys must be registered before being used and must be unregistered before +* the key memory is freed. */ struct lockdep_subclass_key {char __one_byte; } __attribute__ ((__packed__ )); +/* hash_entry is used to keep track of dynamically allocated keys. */ struct lock_class_key { +struct hlist_node hash_entry;struct lockdep_subclass_key subkeys[MAX_LOCKDEP_SUBCLASSES ]; };
@@ -273,6 +277,9 @@ extern void lockdep_set_selftest_task(struct task_struct *task);extern void lockdep_off (void );extern void lockdep_on (void ); +extern void lockdep_register_key (struct lock_class_key *key); +extern void lockdep_unregister_key (struct lock_class_key *key); +/* * These methods are used by specific locking variants (spinlocks, * rwlocks, mutexes and rwsems) to pass init/acquire/release events
@@ -434,6 +441,14 @@ static inline void lockdep_set_selftest_task(struct task_struct *task)*/ struct lock_class_key { }; +static inline void lockdep_register_key (struct lock_class_key *key) +{ +} + +static inline void lockdep_unregister_key (struct lock_class_key *key) +{ +} +/* * The lockdep_map takes no space if lockdep is disabled: */
kernel/locking/lockdep.c +113 -8
158 lines not on this page · raw message
PATCH v7 19/23 kernel/workqueue: Use dynamic lockdep keys for workqueues
In reply to Bart Van AsscheCommit 87915adc3f0a ("workqueue: re-add lockdep dependencies for flushing") improved deadlock checking in the workqueue implementation. Unfortunately that patch also introduced a few false positive lockdep complaints. This patch suppresses these false positives by allocating the workqueue mutex lockdep key dynamically. An example of a false positive lockdep complaint suppressed by this report can be found below. The root cause of the lockdep complaint shown below is that the direct I/O code can call alloc_workqueue() from inside a work item created by another alloc_workqueue() call and that both workqueues share the same lockdep key. This patch avoids that that lockdep complaint is triggered by allocating the work queue lockdep keys dynamically. In other words, this patch guarantees that a unique lockdep key is associated with each work queue mutex.
======================================================
WARNING: possible circular locking dependency detected
4.19.0-dbg+ #1 Not tainted
------------------------------------------------------
fio/4129 is trying to acquire lock:00000000a01cfe1a ((wq_completion)"dio/%s"sb->s_id){+.+.}, at: flush_workqueue+0xd0/0x970
but task is already holding lock:00000000a0acecf9 (&sb->s_type->i_mutex_key#14){+.+.}, at: ext4_file_write_iter+0x154/0x710
which lock already depends on the new lock.
the existing dependency chain (in reverse order) is:
-> #2 (&sb->s_type->i_mutex_key#14){+.+.}:
down_write+0x3d/0x80
__generic_file_fsync+0x77/0xf0
ext4_sync_file+0x3c9/0x780
vfs_fsync_range+0x66/0x100
dio_complete+0x2f5/0x360
dio_aio_complete_work+0x1c/0x20
process_one_work+0x481/0x9f0
worker_thread+0x63/0x5a0
kthread+0x1cf/0x1f0
ret_from_fork+0x24/0x30-> #1 ((work_completion)(&dio->complete_work)){+.+.}:
process_one_work+0x447/0x9f0
worker_thread+0x63/0x5a0
kthread+0x1cf/0x1f0
ret_from_fork+0x24/0x30-> #0 ((wq_completion)"dio/%s"sb->s_id){+.+.}:
lock_acquire+0xc5/0x200
flush_workqueue+0xf3/0x970
drain_workqueue+0xec/0x220
destroy_workqueue+0x23/0x350
sb_init_dio_done_wq+0x6a/0x80
do_blockdev_direct_IO+0x1f33/0x4be0
__blockdev_direct_IO+0x79/0x86
ext4_direct_IO+0x5df/0xbb0
generic_file_direct_write+0x119/0x220
__generic_file_write_iter+0x131/0x2d0
ext4_file_write_iter+0x3fa/0x710
aio_write+0x235/0x330
io_submit_one+0x510/0xeb0
__x64_sys_io_submit+0x122/0x340
do_syscall_64+0x71/0x220
entry_SYSCALL_64_after_hwframe+0x49/0xbeother info that might help us debug this:
Chain exists of: (wq_completion)"dio/%s"sb->s_id --> (work_completion)(&dio->complete_work) --> &sb->s_type->i_mutex_key#14 Possible unsafe locking scenario:
CPU0 CPU1
---- ----
lock(&sb->s_type->i_mutex_key#14);
lock((work_completion)(&dio->complete_work));
lock(&sb->s_type->i_mutex_key#14);lock((wq_completion)"dio/%s"sb->s_id);
*** DEADLOCK ***
1 lock held by fio/4129:
#0: 00000000a0acecf9 (&sb->s_type->i_mutex_key#14){+.+.}, at: ext4_file_write_iter+0x154/0x710
stack backtrace: CPU: 3 PID: 4129 Comm: fio Not tainted 4.19.0-dbg+ #1 Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.10.2-1 04/01/2014 Call Trace: dump_stack+0x86/0xc5 print_circular_bug.isra.32+0x20a/0x218 __lock_acquire+0x1c68/0x1cf0 lock_acquire+0xc5/0x200 flush_workqueue+0xf3/0x970 drain_workqueue+0xec/0x220 destroy_workqueue+0x23/0x350 sb_init_dio_done_wq+0x6a/0x80 do_blockdev_direct_IO+0x1f33/0x4be0 __blockdev_direct_IO+0x79/0x86 ext4_direct_IO+0x5df/0xbb0 generic_file_direct_write+0x119/0x220 __generic_file_write_iter+0x131/0x2d0 ext4_file_write_iter+0x3fa/0x710 aio_write+0x235/0x330 io_submit_one+0x510/0xeb0 __x64_sys_io_submit+0x122/0x340 do_syscall_64+0x71/0x220 entry_SYSCALL_64_after_hwframe+0x49/0xbe
--- include/linux/workqueue.h | 28 +++---------------- kernel/workqueue.c | 59 +++++++++++++++++++++++++++++++++------ 2 files changed, 54 insertions(+), 33 deletions(-)
include/linux/workqueue.h +4 -24
@@ -390,43 +390,23 @@ extern struct workqueue_struct *system_freezable_wq;extern struct workqueue_struct *system_power_efficient_wq;extern struct workqueue_struct *system_freezable_power_efficient_wq; -extern struct workqueue_struct * -__alloc_workqueue_key (const char *fmt,unsigned int flags,int max_active, -struct lock_class_key *key,const char *lock_name, ...)__printf (1 ,6 ); -/** * alloc_workqueue - allocate a workqueue * @fmt: printf format for the name of the workqueue * @flags: WQ_* flags * @max_active: max in-flight work items, 0 for default -* @args...: args for @fmt +* remaining args: args for @fmt * * Allocate a workqueue with the specified parameters. For detailed * information on WQ_* flags, please refer to * Documentation/core-api/workqueue.rst. * -* The __lock_name macro dance is to guarantee that single lock_class_key -* doesn't end up with different namesm, which isn't allowed by lockdep. -* * RETURNS: * Pointer to the allocated workqueue on success, %NULL on failure. */ -#ifdef CONFIG_LOCKDEP -#define alloc_workqueue(fmt, flags, max_active, args...) \ -({ \ - static struct lock_class_key __key; \ - const char *__lock_name; \ - \ - __lock_name = "(wq_completion)"#fmt#args; \ - \ - __alloc_workqueue_key((fmt), (flags), (max_active), \ - &__key, __lock_name, ##args); \ -}) -#else -#define alloc_workqueue(fmt, flags, max_active, args...) \ - __alloc_workqueue_key((fmt), (flags), (max_active), \ - NULL, NULL, ##args) -#endif +struct workqueue_struct *alloc_workqueue (const char *fmt, +unsigned int flags, +int max_active, ...);/** * alloc_ordered_workqueue - allocate an ordered workqueue
kernel/workqueue.c +50 -9
113 lines not on this page · raw message
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
tip-bot for Bart Van Assche
merge bot[tip:locking/core] kernel/workqueue: Use dynamic lockdep keys for workqueues
kernel/workqueue: Use dynamic lockdep keys for workqueues
Commit-ID: 669de8bda87b92ab9a2fc663b3f5743c2ad1ae9f Gitweb: https://git.kernel.org/tip/669de8bda87b92ab9a2fc663b3f5743c2ad1ae9f Author: Bart Van Assche <[email protected]> AuthorDate: Thu, 14 Feb 2019 15:00:54 -0800 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 28 Feb 2019 07:55:47 +0100
kernel/workqueue: Use dynamic lockdep keys for workqueues
The following commit:
87915adc3f0a ("workqueue: re-add lockdep dependencies for flushing")
improved deadlock checking in the workqueue implementation. Unfortunately that patch also introduced a few false positive lockdep complaints.
This patch suppresses these false positives by allocating the workqueue mutex lockdep key dynamically.
An example of a false positive lockdep complaint suppressed by this patch can be found below. The root cause of the lockdep complaint shown below is that the direct I/O code can call alloc_workqueue() from inside a work item created by another alloc_workqueue() call and that both workqueues share the same lockdep key. This patch avoids that that lockdep complaint is triggered by allocating the work queue lockdep keys dynamically.
In other words, this patch guarantees that a unique lockdep key is associated with each work queue mutex.
======================================================
WARNING: possible circular locking dependency detected
4.19.0-dbg+ #1 Not tainted
fio/4129 is trying to acquire lock:
00000000a01cfe1a ((wq_completion)"dio/%s"sb->s_id){+.+.}, at: flush_workqueue+0xd0/0x970
but task is already holding lock:
00000000a0acecf9 (&sb->s_type->i_mutex_key#14){+.+.}, at: ext4_file_write_iter+0x154/0x710
which lock already depends on the new lock.
the existing dependency chain (in reverse order) is:
-> #2 (&sb->s_type->i_mutex_key#14){+.+.}:
down_write+0x3d/0x80
__generic_file_fsync+0x77/0xf0
ext4_sync_file+0x3c9/0x780
vfs_fsync_range+0x66/0x100
dio_complete+0x2f5/0x360
dio_aio_complete_work+0x1c/0x20
process_one_work+0x481/0x9f0
worker_thread+0x63/0x5a0
kthread+0x1cf/0x1f0
ret_from_fork+0x24/0x30-> #1 ((work_completion)(&dio->complete_work)){+.+.}:
process_one_work+0x447/0x9f0
worker_thread+0x63/0x5a0
kthread+0x1cf/0x1f0
ret_from_fork+0x24/0x30-> #0 ((wq_completion)"dio/%s"sb->s_id){+.+.}:
lock_acquire+0xc5/0x200
flush_workqueue+0xf3/0x970
drain_workqueue+0xec/0x220
destroy_workqueue+0x23/0x350
sb_init_dio_done_wq+0x6a/0x80
do_blockdev_direct_IO+0x1f33/0x4be0
__blockdev_direct_IO+0x79/0x86
ext4_direct_IO+0x5df/0xbb0
generic_file_direct_write+0x119/0x220
__generic_file_write_iter+0x131/0x2d0
ext4_file_write_iter+0x3fa/0x710
aio_write+0x235/0x330
io_submit_one+0x510/0xeb0
__x64_sys_io_submit+0x122/0x340
do_syscall_64+0x71/0x220
entry_SYSCALL_64_after_hwframe+0x49/0xbeother info that might help us debug this:
Chain exists of:
(wq_completion)"dio/%s"sb->s_id --> (work_completion)(&dio->complete_work) --> &sb->s_type->i_mutex_key#14
Possible unsafe locking scenario: CPU0 CPU1
---- ----
lock(&sb->s_type->i_mutex_key#14);
lock((work_completion)(&dio->complete_work));
lock(&sb->s_type->i_mutex_key#14);
lock((wq_completion)"dio/%s"sb->s_id);*** DEADLOCK ***
1 lock held by fio/4129:
#0: 00000000a0acecf9 (&sb->s_type->i_mutex_key#14){+.+.}, at: ext4_file_write_iter+0x154/0x710
stack backtrace: CPU: 3 PID: 4129 Comm: fio Not tainted 4.19.0-dbg+ #1 Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.10.2-1 04/01/2014 Call Trace: dump_stack+0x86/0xc5 print_circular_bug.isra.32+0x20a/0x218 __lock_acquire+0x1c68/0x1cf0 lock_acquire+0xc5/0x200 flush_workqueue+0xf3/0x970 drain_workqueue+0xec/0x220 destroy_workqueue+0x23/0x350 sb_init_dio_done_wq+0x6a/0x80 do_blockdev_direct_IO+0x1f33/0x4be0 __blockdev_direct_IO+0x79/0x86 ext4_direct_IO+0x5df/0xbb0 generic_file_direct_write+0x119/0x220 __generic_file_write_iter+0x131/0x2d0 ext4_file_write_iter+0x3fa/0x710 aio_write+0x235/0x330 io_submit_one+0x510/0xeb0 __x64_sys_io_submit+0x122/0x340 do_syscall_64+0x71/0x220 entry_SYSCALL_64_after_hwframe+0x49/0xbe
--- include/linux/workqueue.h | 28 ++++------------------ kernel/workqueue.c | 59 +++++++++++++++++++++++++++++++++++++++-------- 2 files changed, 54 insertions(+), 33 deletions(-)
include/linux/workqueue.h +4 -24
@@ -390,43 +390,23 @@ extern struct workqueue_struct *system_freezable_wq;extern struct workqueue_struct *system_power_efficient_wq;extern struct workqueue_struct *system_freezable_power_efficient_wq; -extern struct workqueue_struct * -__alloc_workqueue_key (const char *fmt,unsigned int flags,int max_active, -struct lock_class_key *key,const char *lock_name, ...)__printf (1 ,6 ); -/** * alloc_workqueue - allocate a workqueue * @fmt: printf format for the name of the workqueue * @flags: WQ_* flags * @max_active: max in-flight work items, 0 for default -* @args...: args for @fmt +* remaining args: args for @fmt * * Allocate a workqueue with the specified parameters. For detailed * information on WQ_* flags, please refer to * Documentation/core-api/workqueue.rst. * -* The __lock_name macro dance is to guarantee that single lock_class_key -* doesn't end up with different namesm, which isn't allowed by lockdep. -* * RETURNS: * Pointer to the allocated workqueue on success, %NULL on failure. */ -#ifdef CONFIG_LOCKDEP -#define alloc_workqueue(fmt, flags, max_active, args...) \ -({ \ - static struct lock_class_key __key; \ - const char *__lock_name; \ - \ - __lock_name = "(wq_completion)"#fmt#args; \ - \ - __alloc_workqueue_key((fmt), (flags), (max_active), \ - &__key, __lock_name, ##args); \ -}) -#else -#define alloc_workqueue(fmt, flags, max_active, args...) \ - __alloc_workqueue_key((fmt), (flags), (max_active), \ - NULL, NULL, ##args) -#endif +struct workqueue_struct *alloc_workqueue (const char *fmt, +unsigned int flags, +int max_active, ...);/** * alloc_ordered_workqueue - allocate an ordered workqueue
kernel/workqueue.c +50 -9
113 lines not on this page · raw message
PATCH v7 20/23 locking/spinlock: Introduce spin_lock_init_key()
In reply to Bart Van AsscheSome code uses nested locking of different spinlocks that share a lock class. That results in false positives because spin_lock_init() forces these instances to share a lock class. Make it possible to avoid these false positives by allowing spinlock users to specify the lock class at runtime.
--- include/linux/spinlock.h | 15 +++++++++++++++ 1 file changed, 15 insertions(+)
include/linux/spinlock.h +15 -0
@@ -99,10 +99,19 @@ do { \ \ __raw_spin_lock_init((lock), #lock, &__key); \ } while (0) +#define raw_spin_lock_init_key (lock, key) \ + __raw_spin_lock_init((lock), #lock, key)#else +# define raw_spin_lock_init (lock) \ do { *(lock) = __RAW_SPIN_LOCK_UNLOCKED(lock); } while (0) +static inline void raw_spin_lock_init_key (struct raw_spinlock *lock, +struct lock_class_key *key) +{ + *(lock) =__RAW_SPIN_LOCK_UNLOCKED (lock); +} +#endif #define raw_spin_is_locked (lock) arch_spin_is_locked(&(lock)->raw_lock)
@@ -324,6 +333,12 @@ do { \raw_spin_lock_init (&(_lock)->rlock); \ } while (0) +#define spin_lock_init_key (_lock, _key) \ +do { \ + spinlock_check(_lock); \ + raw_spin_lock_init_key(&(_lock)->rlock, _key); \ +} while (0) + static __always_inline void spin_lock(spinlock_t *lock) {raw_spin_lock (&lock->rlock);
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
PATCH v7 21/23 block: Avoid that flushing triggers a lockdep complaint
In reply to Bart Van AsscheAvoid that running test nvme/012 from the blktests suite triggers the following false positive lockdep complaint:
============================================
WARNING: possible recursive locking detected 5.0.0-rc3-xfstests-00015-g1236f7d60242 #841 Not tainted
--------------------------------------------
ksoftirqd/1/16 is trying to acquire lock:000000000282032e (&(&fq->mq_flush_lock)->rlock){..-.}, at: flush_end_io+0x4e/0x1d0
but task is already holding lock:00000000cbadcbc2 (&(&fq->mq_flush_lock)->rlock){..-.}, at: flush_end_io+0x4e/0x1d0
other info that might help us debug this:
Possible unsafe locking scenario:
CPU0
---- lock(&(&fq->mq_flush_lock)->rlock);
lock(&(&fq->mq_flush_lock)->rlock);
*** DEADLOCK ***
May be due to missing lock nesting notation
1 lock held by ksoftirqd/1/16:
#0: 00000000cbadcbc2 (&(&fq->mq_flush_lock)->rlock){..-.}, at: flush_end_io+0x4e/0x1d0
stack backtrace: CPU: 1 PID: 16 Comm: ksoftirqd/1 Not tainted 5.0.0-rc3-xfstests-00015-g1236f7d60242 #841 Hardware name: Google Google Compute Engine/Google Compute Engine, BIOS Google 01/01/2011 Call Trace: dump_stack+0x67/0x90 __lock_acquire.cold.45+0x2b4/0x313 lock_acquire+0x98/0x160 _raw_spin_lock_irqsave+0x3b/0x80 flush_end_io+0x4e/0x1d0 blk_mq_complete_request+0x76/0x110 nvmet_req_complete+0x15/0x110 [nvmet] nvmet_bio_done+0x27/0x50 [nvmet] blk_update_request+0xd7/0x2d0 blk_mq_end_request+0x1a/0x100 blk_flush_complete_seq+0xe5/0x350 flush_end_io+0x12f/0x1d0 blk_done_softirq+0x9f/0xd0 __do_softirq+0xca/0x440 run_ksoftirqd+0x24/0x50 smpboot_thread_fn+0x113/0x1e0 kthread+0x121/0x140 ret_from_fork+0x3a/0x50
--- block/blk-flush.c | 5 ++++- block/blk.h | 1 + 2 files changed, 5 insertions(+), 1 deletion(-)
block/blk-flush.c +4 -1
@@ -70,6 +70,7 @@#include <linux/blkdev.h> #include <linux/gfp.h> #include <linux/blk-mq.h> +#include <linux/lockdep.h> #include "blk.h" #include "blk-mq.h"
@@ -472,7 +473,8 @@ struct blk_flush_queue *blk_alloc_flush_queue(struct request_queue *q,if (!fq) goto fail; -spin_lock_init (&fq->mq_flush_lock); +lockdep_register_key (&fq->key); +spin_lock_init_key (&fq->mq_flush_lock, &fq->key); rq_sz =round_up (rq_sz + cmd_size,cache_line_size ()); fq->flush_rq =kzalloc_node (rq_sz, flags, node);
@@ -497,6 +499,7 @@ void blk_free_flush_queue(struct blk_flush_queue *fq)if (!fq)return ; +lockdep_unregister_key (&fq->key);kfree (fq->flush_rq);kfree (fq); }
block/blk.h +1 -0
@@ -28,6 +28,7 @@ struct blk_flush_queue {* at the same time */ struct request *orig_rq; +struct lock_class_key key;spinlock_t mq_flush_lock; };
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
Re: [PATCH v7 21/23] block: Avoid that flushing triggers a lockdep complaint
Quoted 95 lines · Bart Van Assche
Avoid that running test nvme/012 from the blktests suite triggers the following false positive lockdep complaint:
============================================
WARNING: possible recursive locking detected 5.0.0-rc3-xfstests-00015-g1236f7d60242 #841 Not tainted
--------------------------------------------
ksoftirqd/1/16 is trying to acquire lock:000000000282032e(&(&fq->mq_flush_lock)->rlock){..-.}, at:flush_end_io+0x4e/0x1d0but task is already holding lock:
00000000cbadcbc2(&(&fq->mq_flush_lock)->rlock){..-.}, at:flush_end_io+0x4e/0x1d0other info that might help us debug this:
Possible unsafe locking scenario:CPU0 ----lock(&(&fq->mq_flush_lock)->rlock);
lock(&(&fq->mq_flush_lock)->rlock);*** DEADLOCK ***
May be due to missing lock nesting notation
1 lock held by ksoftirqd/1/16:
#0:00000000cbadcbc2(&(&fq->mq_flush_lock)->rlock){..-.}, at:flush_end_io+0x4e/0x1d0stack backtrace: CPU: 1 PID: 16 Comm: ksoftirqd/1 Not tainted 5.0.0-rc3-xfstests-00015-g1236f7d60242 #841 Hardware name: Google Google Compute Engine/Google Compute Engine, BIOS Google 01/01/2011 Call Trace: dump_stack+0x67/0x90 __lock_acquire.cold.45+0x2b4/0x313 lock_acquire+0x98/0x160 _raw_spin_lock_irqsave+0x3b/0x80 flush_end_io+0x4e/0x1d0 blk_mq_complete_request+0x76/0x110 nvmet_req_complete+0x15/0x110 [nvmet] nvmet_bio_done+0x27/0x50 [nvmet] blk_update_request+0xd7/0x2d0 blk_mq_end_request+0x1a/0x100 blk_flush_complete_seq+0xe5/0x350 flush_end_io+0x12f/0x1d0 blk_done_softirq+0x9f/0xd0 __do_softirq+0xca/0x440 run_ksoftirqd+0x24/0x50 smpboot_thread_fn+0x113/0x1e0 kthread+0x121/0x140 ret_from_fork+0x3a/0x50Cc Jens Axboe <[email protected]>Cc Ming Lei <[email protected]>Cc Theodore Ts'o <[email protected]>Signed-off-by Bart Van Assche <[email protected]>--- block/blk-flush.c | 5 ++++- block/blk.h | 1 + 2 files changed, 5 insertions(+), 1 deletion(-)block/blk-flush.c +4
-1@@ -70,6 +70,7 @@#include <linux/blkdev.h> #include <linux/gfp.h> #include <linux/blk-mq.h> +#include <linux/lockdep.h> #include "blk.h" #include "blk-mq.h" @@ -472,7 +473,8 @@ struct blk_flush_queue *blk_alloc_flush_queue(struct request_queue *q,if (!fq) goto fail; -spin_lock_init (&fq->mq_flush_lock); +lockdep_register_key (&fq->key); +spin_lock_init_key (&fq->mq_flush_lock, &fq->key); rq_sz =round_up (rq_sz + cmd_size,cache_line_size ()); fq->flush_rq =kzalloc_node (rq_sz, flags, node);@@ -497,6 +499,7 @@ void blk_free_flush_queue(struct blk_flush_queue *fq)if (!fq)return ; +lockdep_unregister_key (&fq->key);kfree (fq->flush_rq);kfree (fq); }block/blk.h +0
-0
block/blk.h struct blk_flush_queue { · line 34
Quoted 7 lines
block/blk.h +1
-0@@ -28,6 +28,7 @@ struct blk_flush_queue {* at the same time */ struct request *orig_rq; +struct lock_class_key key;spinlock_t mq_flush_lock; };
Hi Bart,
Did you look at the following comment?
https://marc.info/?l=linux-block&m=155014828206209&w=2
There might be lots of blk_flush_queue instance which is allocated for each hctx, then lots of class key slot may be wasted.
So I suggest to use one nvmet_loop_flush_lock_key for this particular issue, something like the following patch:
drivers/nvme/target/loop.c +7 -1
@@ -524,7 +524,9 @@ static const struct nvme_ctrl_ops nvme_loop_ctrl_ops = {static int nvme_loop_create_io_queues (struct nvme_loop_ctrl *ctrl) { -int ret; +static struct lock_class_key nvme_loop_flush_lock_key; +int ret, i; +struct blk_mq_hw_ctx *hctx; ret =nvme_loop_init_io_queues (ctrl);if (ret)
@@ -553,6 +555,10 @@ static int nvme_loop_create_io_queues(struct nvme_loop_ctrl *ctrl) goto out_free_tagset; } +queue_for_each_hw_ctx (ctrl->ctrl.connect_q, hctx, i) +lockdep_set_class (&hctx->fq->mq_flush_lock, + &nvme_loop_flush_lock_key); + ret =nvme_loop_connect_io_queues (ctrl);if (ret) goto out_cleanup_connect_q;
--
Ming
Re: [PATCH v7 21/23] block: Avoid that flushing triggers a lockdep complaint
Quoted 13 lines · Ming Lei
There might be lots of
blk_flush_queueinstance which is allocated for each hctx, then lots of class key slot may be wasted.So I suggest to use one
nvmet_loop_flush_lock_keyfor this particular issue, something like the following patch:drivers/nvme/target/loop.c +1
-1--- a/drivers/nvme/target/loop.c +-+-+- b/drivers/nvme/target/loop.c@@-524,7 +-524,9 @@static const struct
nvme_ctrl_opsnvme_loop_ctrl_ops={> static intnvme_loop_create_io_queues(struct nvme_loop_ctrl *ctrl)
{>- int ret;>+- static structlock_class_keynvme_loop_flush_lock_key;>+- int ret, i;>+- structblk_mq_hw_ctx*hctx;>
Quoted 8 lines
ret =nvme_loop_init_io_queues(ctrl);> if (ret) @@-553,6 +-555,10 @@static int nvme_loop_create_io_queues(struct nvme_loop_ctrl *ctrl) goto out_free_tagset;> }> +- queue_for_each_hw_ctx(ctrl->ctrl.connect_q, hctx, i) +- lockdep_set_class(&hctx->fq->mq_flush_lock, +- &nvme_loop_flush_lock_key);>+- ret =nvme_loop_connect_io_queues(ctrl);> if (ret) goto out_cleanup_connect_q;
Hi Ming,
Thanks for your feedback.
Are you aware that sizeof(struct lock_class_key) is zero if lockdep is disabled? Does this alleviate your concern?
I'm not enthusiast about your patch. I don't think that block layer users should touch the lock class key of the flush queue. That's a key that should be set by the block layer core.
Anyway, let's drop patches 20/23 and 21/23 from this series and let's continue this discussion on the linux-block mailing list after agreement has been reached about the "dynamic lockdep key"approach.
Bart.
Re: [PATCH v7 21/23] block: Avoid that flushing triggers a lockdep complaint
Quoted 36 lines · Bart Van Assche
Quoted 22 lines · Ming Lei
There might be lots of
blk_flush_queueinstance which is allocated for each hctx, then lots of class key slot may be wasted.So I suggest to use one
nvmet_loop_flush_lock_keyfor this particular issue, something like the following patch:drivers/nvme/target/loop.c +3
-1@@ -524,7 +524,9 @@ static const struct nvme_ctrl_ops nvme_loop_ctrl_ops = {static int nvme_loop_create_io_queues (struct nvme_loop_ctrl *ctrl) { -int ret; +static struct lock_class_key nvme_loop_flush_lock_key; +int ret, i; +struct blk_mq_hw_ctx *hctx; ret =nvme_loop_init_io_queues (ctrl);if (ret)drivers/nvme/target/loop.c static int nvme_loop_create_io_queues(struct nvme_loop_ctrl *ctrl) · line 564
Quoted 10 lines
drivers/nvme/target/loop.c +4
-0@@ -553,6 +555,10 @@ static int nvme_loop_create_io_queues(struct nvme_loop_ctrl *ctrl) goto out_free_tagset; } +queue_for_each_hw_ctx (ctrl->ctrl.connect_q, hctx, i) +lockdep_set_class (&hctx->fq->mq_flush_lock, + &nvme_loop_flush_lock_key); + ret =nvme_loop_connect_io_queues (ctrl);if (ret) goto out_cleanup_connect_q;Hi Ming,
Quoted 4 lines
Thanks for your feedback.
Are you aware that
sizeof(struct lock_class_key)is zero if lockdep is disabled?
Yes.
Quoted 1 line
Does this alleviate your concern?
No, I mean in case of CONFIG_LOCKDP.
1) MAX_LOCKDEP_KEYS is defined as 8k-1
2) lock validation runs as graph search algorithm actually, and each lock class acts as one graph vertex.
So more lock class will make the lock validation much slower, also lock class key may be overflow.
Quoted 4 lines
I'm not enthusiast about your patch. I don't think that block layer users should touch the lock class key of the flush queue. That's a key that should be set by the block layer core.
Why? lockdep_set_class is used tree-wide actually.
Thanks,
Ming
Peter Zijlstra
maintainerRe: [PATCH v7 21/23] block: Avoid that flushing triggers a lockdep complaint
In reply to Ming LeiQuoted 2 lines · Ming Lei
There might be lots of
blk_flush_queueinstance which is allocated for each hctx, then lots of class key slot may be wasted.
What is 'lots' ? for someone who doesn't really know all that much about the block layer.
Re: [PATCH v7 21/23] block: Avoid that flushing triggers a lockdep complaint
Quoted 6 lines · Peter Zijlstra
Quoted 2 lines · Ming Lei
There might be lots of
blk_flush_queueinstance which is allocated for each hctx, then lots of class key slot may be wasted.What is 'lots' ? for someone who doesn't really know all that much about the block layer.
Each hw queue has one instance of blk_flush_queue, and one device may has lots of hw queues(may be > all possible cpus, such as nvme), and there may be lots of block devices in one system.
Suppose one system has 10 NVMe hosts, 8 disks attached to each host, and 256 CPU cores in the system, there can be 10 * 8 * 256 = 20K instances of blk_flush_queue.
Not mention there are other block devices(loop, nbd, scsi, ...) in the system.
That is why I suggest to use one single lock class for addressing this nvme loop specific issue:
https://marc.info/?l=linux-kernel&m=155019765724564&w=2
Thanks,
Ming
Peter Zijlstra
maintainerRe: [PATCH v7 21/23] block: Avoid that flushing triggers a lockdep complaint
Quoted 16 lines · Ming Lei
Quoted 6 lines · Peter Zijlstra
Quoted 2 lines · Ming Lei
There might be lots of
blk_flush_queueinstance which is allocated for each hctx, then lots of class key slot may be wasted.What is 'lots' ? for someone who doesn't really know all that much about the block layer.
Each hw queue has one instance of
blk_flush_queue, and one device may has lots of hwqueues(may be > all possible cpus, such as nvme), and there may be lots of block devices in one system.Suppose one system has 10 NVMe hosts, 8 disks attached to each host, and 256 CPU cores in the system, there can be 10 * 8 * 256 = 20K instances of
blk_flush_queue.
Quoted 6 lines
Not mention there are other block
devices(loop, nbd, scsi, ...)in the system.That is why I suggest to use one single lock class for addressing this nvme loop specific issue:
Right; that is rather a lot. But what causes the recursion, and thus how is it specific to NVME ?
Re: [PATCH v7 21/23] block: Avoid that flushing triggers a lockdep complaint
Quoted 19 lines · Peter Zijlstra
Quoted 18 lines · Ming Lei
Quoted 6 lines · Peter Zijlstra
Quoted 2 lines · Ming Lei
There might be lots of
blk_flush_queueinstance which is allocated for each hctx, then lots of class key slot may be wasted.What is 'lots' ? for someone who doesn't really know all that much about the block layer.
Each hw queue has one instance of
blk_flush_queue, and one device may has lots of hwqueues(may be > all possible cpus, such as nvme), and there may be lots of block devices in one system.Suppose one system has 10 NVMe hosts, 8 disks attached to each host, and 256 CPU cores in the system, there can be 10 * 8 * 256 = 20K instances of
blk_flush_queue.Not mention there are other block
devices(loop, nbd, scsi, ...)in the system.
Quoted 7 lines
Quoted 4 lines
That is why I suggest to use one single lock class for addressing this nvme loop specific issue:
Right; that is rather a lot. But what causes the recursion, and thus how is it specific to NVME ?
The recursion is nvme-loop specific, see the following link:
https://marc.info/?l=linux-block&m=155003205030566&w=2
Thanks,
Ming
Peter Zijlstra
maintainerRe: [PATCH v7 21/23] block: Avoid that flushing triggers a lockdep complaint
In reply to Bart Van Asscheblock/blk-flush.c struct blk_flush_queue *blk_alloc_flush_queue(struct request_queue *q, · line 477
Quoted 7 lines · Bart Van Assche
block/blk-flush.c +2
-1@@ -472,7 +473,8 @@ struct blk_flush_queue *blk_alloc_flush_queue(struct request_queue *q,if (!fq) goto fail; -spin_lock_init (&fq->mq_flush_lock); +lockdep_register_key (&fq->key); +spin_lock_init_key (&fq->mq_flush_lock, &fq->key);
What's wrong with:
spin_lock_init(&fq->wq_flush_lock); lockdep_register_key(&fq->key); lockdep_set_class(&fq->wq_flush_lock, &fq->key);
?
Re: [PATCH v7 21/23] block: Avoid that flushing triggers a lockdep complaint
Quoted 9 lines · Peter Zijlstra
Review
Quoted 4 lines · Bart Van Assche
@@-472,7 +-473,8 @@struct
blk_flush_queue*blk_alloc_flush_queue(structrequest_queue*q,if (!fq) goto fail;>>(quoted diff) +0
-1- spin_lock_init(&fq->mq_flush_lock);>>+- lockdep_register_key(&fq->key);>>+- spin_lock_init_key(&fq->mq_flush_lock, &fq->key);>What's wrong with:
spin_lock_init(&fq->wq_flush_lock);> lockdep_register_key(&fq->key);> lockdep_set_class(&fq->wq_flush_lock, &fq->key);>?
Hi Peter,
That's an approach that I had not yet considered. I'm fine with the lockdep_set_class() version.
Bart.
PATCH v7 22/23 lockdep tests: Fix run_tests.sh
In reply to Bart Van AsscheApparently the execute bits were set for the tests/*.sh scripts on my test setup but these are not set in the kernel tree. Fix this by adding the interpreter path in front of the script paths.
--- tools/lib/lockdep/run_tests.sh | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
tools/lib/lockdep/run_tests.sh +3 -3
@@ -11,7 +11,7 @@ find tests -name '*.c' | sort | while read -r i; do testname=$(basename "$i" .c) echo -ne "$testname... " if gcc -o "tests/$testname" -pthread "$i" liblockdep.a -Iinclude -D__USE_LIBLOCKDEP && - timeout 1 "tests/$testname" 2>&1 | "tests/${testname}.sh"; then + timeout 1 "tests/$testname" 2>&1 | /bin/bash "tests/${testname}.sh"; then echo "PASSED!" else echo "FAILED!"
@@ -24,7 +24,7 @@ find tests -name '*.c' | sort | while read -r i; do echo -ne "(PRELOAD) $testname... " if gcc -o "tests/$testname" -pthread -Iinclude "$i" && timeout 1 ./lockdep "tests/$testname" 2>&1 | - "tests/${testname}.sh"; then + /bin/bash "tests/${testname}.sh"; then echo "PASSED!" else echo "FAILED!"
@@ -37,7 +37,7 @@ find tests -name '*.c' | sort | while read -r i; do echo -ne "(PRELOAD + Valgrind) $testname... " if gcc -o "tests/$testname" -pthread -Iinclude "$i" && { timeout 10 valgrind --read-var-info=yes ./lockdep "./tests/$testname" >& "tests/${testname}.vg.out"; true; } && - "tests/${testname}.sh" < "tests/${testname}.vg.out" && + /bin/bash "tests/${testname}.sh" < "tests/${testname}.vg.out" && ! grep -Eq '(^==[0-9]*== (Invalid |Uninitialised ))|Mismatched free|Source and destination overlap| UME ' "tests/${testname}.vg.out"; then echo "PASSED!" else
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
tip-bot for Bart Van Assche
merge bot[tip:locking/core] lockdep/lib/tests: Fix run_tests.sh
lockdep/lib/tests: Fix run_tests.sh
Commit-ID: d93ac78bf7b37db36fa00225f8e9a14c7ed1b2ba Gitweb: https://git.kernel.org/tip/d93ac78bf7b37db36fa00225f8e9a14c7ed1b2ba Author: Bart Van Assche <[email protected]> AuthorDate: Thu, 14 Feb 2019 15:00:57 -0800 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 28 Feb 2019 07:55:48 +0100
lockdep/lib/tests: Fix run_tests.sh
Apparently the execute bits were set for the tests/*.sh scripts on my test setup but these are not set in the kernel tree. Fix this by adding the interpreter path in front of the script paths.
--- tools/lib/lockdep/run_tests.sh | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
tools/lib/lockdep/run_tests.sh +3 -3
@@ -11,7 +11,7 @@ find tests -name '*.c' | sort | while read -r i; do testname=$(basename "$i" .c) echo -ne "$testname... " if gcc -o "tests/$testname" -pthread "$i" liblockdep.a -Iinclude -D__USE_LIBLOCKDEP && - timeout 1 "tests/$testname" 2>&1 | "tests/${testname}.sh"; then + timeout 1 "tests/$testname" 2>&1 | /bin/bash "tests/${testname}.sh"; then echo "PASSED!" else echo "FAILED!"
@@ -24,7 +24,7 @@ find tests -name '*.c' | sort | while read -r i; do echo -ne "(PRELOAD) $testname... " if gcc -o "tests/$testname" -pthread -Iinclude "$i" && timeout 1 ./lockdep "tests/$testname" 2>&1 | - "tests/${testname}.sh"; then + /bin/bash "tests/${testname}.sh"; then echo "PASSED!" else echo "FAILED!"
@@ -37,7 +37,7 @@ find tests -name '*.c' | sort | while read -r i; do echo -ne "(PRELOAD + Valgrind) $testname... " if gcc -o "tests/$testname" -pthread -Iinclude "$i" && { timeout 10 valgrind --read-var-info=yes ./lockdep "./tests/$testname" >& "tests/${testname}.vg.out"; true; } && - "tests/${testname}.sh" < "tests/${testname}.vg.out" && + /bin/bash "tests/${testname}.sh" < "tests/${testname}.vg.out" && ! grep -Eq '(^==[0-9]*== (Invalid |Uninitialised ))|Mismatched free|Source and destination overlap| UME ' "tests/${testname}.vg.out"; then echo "PASSED!" else
PATCH v7 23/23 lockdep tests: Test dynamic key registration
In reply to Bart Van AsscheMake sure that the lockdep_register_key() and lockdep_unregister_key() code is tested when running the lockdep tests.
--- tools/lib/lockdep/include/liblockdep/common.h | 2 ++ tools/lib/lockdep/include/liblockdep/mutex.h | 11 ++++++----- tools/lib/lockdep/tests/ABBA.c | 9 +++++++++ 3 files changed, 17 insertions(+), 5 deletions(-)
tools/lib/lockdep/include/liblockdep/common.h +2 -0
@@ -45,6 +45,8 @@ void lock_acquire(struct lockdep_map *lock, unsigned int subclass,void lock_release (struct lockdep_map *lock,int nested,unsigned long ip);void lockdep_reset_lock (struct lockdep_map *lock); +void lockdep_register_key (struct lock_class_key *key); +void lockdep_unregister_key (struct lock_class_key *key);extern void debug_check_no_locks_freed (const void *from,unsigned long len);#define STATIC_LOCKDEP_MAP_INIT (_name, _key) \
tools/lib/lockdep/include/liblockdep/mutex.h +6 -5
@@ -7,6 +7,7 @@struct liblockdep_pthread_mutex {pthread_mutex_t mutex; +struct lock_class_key key;struct lockdep_map dep_map; };
@@ -27,11 +28,10 @@ static inline int __mutex_init(liblockdep_pthread_mutex_t *lock,return pthread_mutex_init (&lock->mutex, __mutexattr); } -#define liblockdep_pthread_mutex_init (mutex, mutexattr) \ -({ \ - static struct lock_class_key __key; \ - \ - __mutex_init((mutex), #mutex, &__key, (mutexattr)); \ +#define liblockdep_pthread_mutex_init (mutex, mutexattr) \ +({ \ + lockdep_register_key(&(mutex)->key); \ + __mutex_init((mutex), #mutex, &(mutex)->key, (mutexattr)); \ })static inline int liblockdep_pthread_mutex_lock (liblockdep_pthread_mutex_t *lock)
@@ -55,6 +55,7 @@ static inline int liblockdep_pthread_mutex_trylock(liblockdep_pthread_mutex_t *lstatic inline int liblockdep_pthread_mutex_destroy (liblockdep_pthread_mutex_t *lock) {lockdep_reset_lock (&lock->dep_map); +lockdep_unregister_key (&lock->key);return pthread_mutex_destroy (&lock->mutex); }
tools/lib/lockdep/tests/ABBA.c +9 -0
@@ -14,4 +14,13 @@ void main(void)pthread_mutex_destroy (&b);pthread_mutex_destroy (&a); + +pthread_mutex_init (&a,NULL ); +pthread_mutex_init (&b,NULL ); + +LOCK_UNLOCK_2 (a, b); +LOCK_UNLOCK_2 (b, a); + +pthread_mutex_destroy (&b); +pthread_mutex_destroy (&a); }
Signature · 1 line
2.21.0.rc0.258.g878e2cd30e-goog
tip-bot for Bart Van Assche
merge bot[tip:locking/core] lockdep/lib/tests: Test dynamic key registration
lockdep/lib/tests: Test dynamic key registration
Commit-ID: f214737b75b0ee79763b5c058b9d5e83d711348d Gitweb: https://git.kernel.org/tip/f214737b75b0ee79763b5c058b9d5e83d711348d Author: Bart Van Assche <[email protected]> AuthorDate: Thu, 14 Feb 2019 15:00:58 -0800 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 28 Feb 2019 07:55:48 +0100
lockdep/lib/tests: Test dynamic key registration
Make sure that the lockdep_register_key() and lockdep_unregister_key() code is tested when running the lockdep tests.
--- tools/lib/lockdep/include/liblockdep/common.h | 2 ++ tools/lib/lockdep/include/liblockdep/mutex.h | 11 ++++++----- tools/lib/lockdep/tests/ABBA.c | 9 +++++++++ 3 files changed, 17 insertions(+), 5 deletions(-)
tools/lib/lockdep/include/liblockdep/common.h +2 -0
@@ -45,6 +45,8 @@ void lock_acquire(struct lockdep_map *lock, unsigned int subclass,void lock_release (struct lockdep_map *lock,int nested,unsigned long ip);void lockdep_reset_lock (struct lockdep_map *lock); +void lockdep_register_key (struct lock_class_key *key); +void lockdep_unregister_key (struct lock_class_key *key);extern void debug_check_no_locks_freed (const void *from,unsigned long len);#define STATIC_LOCKDEP_MAP_INIT (_name, _key) \
tools/lib/lockdep/include/liblockdep/mutex.h +6 -5
@@ -7,6 +7,7 @@struct liblockdep_pthread_mutex {pthread_mutex_t mutex; +struct lock_class_key key;struct lockdep_map dep_map; };
@@ -27,11 +28,10 @@ static inline int __mutex_init(liblockdep_pthread_mutex_t *lock,return pthread_mutex_init (&lock->mutex, __mutexattr); } -#define liblockdep_pthread_mutex_init (mutex, mutexattr) \ -({ \ - static struct lock_class_key __key; \ - \ - __mutex_init((mutex), #mutex, &__key, (mutexattr)); \ +#define liblockdep_pthread_mutex_init (mutex, mutexattr) \ +({ \ + lockdep_register_key(&(mutex)->key); \ + __mutex_init((mutex), #mutex, &(mutex)->key, (mutexattr)); \ })static inline int liblockdep_pthread_mutex_lock (liblockdep_pthread_mutex_t *lock)
@@ -55,6 +55,7 @@ static inline int liblockdep_pthread_mutex_trylock(liblockdep_pthread_mutex_t *lstatic inline int liblockdep_pthread_mutex_destroy (liblockdep_pthread_mutex_t *lock) {lockdep_reset_lock (&lock->dep_map); +lockdep_unregister_key (&lock->key);return pthread_mutex_destroy (&lock->mutex); }
tools/lib/lockdep/tests/ABBA.c +9 -0
@@ -14,4 +14,13 @@ void main(void)pthread_mutex_destroy (&b);pthread_mutex_destroy (&a); + +pthread_mutex_init (&a,NULL ); +pthread_mutex_init (&b,NULL ); + +LOCK_UNLOCK_2 (a, b); +LOCK_UNLOCK_2 (b, a); + +pthread_mutex_destroy (&b); +pthread_mutex_destroy (&a); }
Quoted 8 lines · Bart Van Assche
A known shortcoming of the current lockdep implementation is that it requires lock keys to be allocated statically. This forces certain unrelated synchronization objects to share keys and this key sharing can cause false positive deadlock reports. This patch series adds support for dynamic keys in the lockdep code and eliminates a class of false positive reports from the workqueue implementation.
Please consider these patches for kernel v5.1.
Hi Peter and Ingo,
Do you have any feedback about this patch series that you would like to share? If none of you has the time to do a full review of this patch series before the v5.1 merge window opens: how about queuing only the first ten patches of this patch series for kernel v5.1? The first ten patches of this series are small and easy to review.
Thanks,
Bart.
Peter Zijlstra
maintainerQuoted 8 lines · Bart Van Assche
Quoted 7 lines · Bart Van Assche
A known shortcoming of the current lockdep implementation is that it requires lock keys to be allocated statically. This forces certain unrelated synchronization objects to share keys and this key sharing can cause false positive deadlock reports. This patch series adds support for dynamic keys in the lockdep code and eliminates a class of false positive reports from the workqueue implementation.
Quoted 5 lines
Quoted 1 line
Please consider these patches for kernel v5.1.
Hi Peter and Ingo,
Do you have any feedback about this patch series that you would like to share?
I've gone over all and I think it looks ok now; I'll give it another round tomorrow^Wmonday and then queue bits.
So far the only changes I've made are the below. I'm not entirely sure on the unconditional validity check on DEBUG_LOCKDEP, maybe I'll add a boot param for that.
---
kernel/locking/lockdep.c +17 -12
@@ -75,8 +75,6 @@ module_param(lock_stat, int, 0644);#define lock_stat 0#endif -static bool check_data_structure_consistency; -/* * lockdep_lock: protects the lockdep graph, the hashes and the * class/list/hash allocators.
@@ -792,6 +790,8 @@ static bool assign_lock_key(struct lockdreturn true; } +#ifdef CONFIG_DEBUG_LOCKDEP +/* Check whether element @e occurs in list @h */ static bool in_list (struct list_head *e,struct list_head *h) {
@@ -856,15 +856,15 @@ static bool check_lock_chain_key(struct* The 'unsigned long long' casts avoid that a compiler warning * is reported when building tools/lib/lockdep. */ -if (chain->chain_key != chain_key) +if (chain->chain_key != chain_key) {printk (KERN_INFO "chain %lld: key %#llx <> %#llx\n" , (unsigned long long )(chain - lock_chains), (unsigned long long )chain->chain_key, (unsigned long long )chain_key); -return chain->chain_key == chain_key; -#else -return true; +return false; + }#endif +return true; }static bool in_any_zapped_class_list (struct lock_class *class)
@@ -872,10 +872,10 @@ static bool in_any_zapped_class_list(strstruct pending_free *pf;int i; -for (i =0 , pf = delayed_free.pf; i <ARRAY_SIZE (delayed_free.pf); - i++, pf++) +for (i =0 , pf = delayed_free.pf; i <ARRAY_SIZE (delayed_free.pf); i++, pf++) {if (in_list (&class->lock_entry, &pf->zapped))return true; + }return false; }
@@ -897,7 +897,6 @@ static bool check_data_structures(void)printk (KERN_INFO "class %px/%s is not in any class list\n" , class, class->name ? :"(?)" );return false; -return false; } }
@@ -954,6 +953,12 @@ static bool check_data_structures(void) return true; } +#else /* CONFIG_DEBUG_LOCKDEP */ + +static inline bool check_data_structures (void ) {return true; } + +#endif /* CONFIG_DEBUG_LOCKDEP */ +/* * Initialize the lock_classes[] array elements, the free_lock_classes list * and also the delayed_free structure.
@@ -4480,10 +4485,11 @@ static void remove_class_from_lock_chainif (chain_hlocks[i] != class - lock_classes)continue ;/* The code below leaks one chain_hlock[] entry. */ -if (--chain->depth >0 ) +if (--chain->depth >0 ) {memmove (&chain_hlocks[i], &chain_hlocks[i +1 ], (chain->base + chain->depth - i) *sizeof (chain_hlocks[0 ])); + }/* * Each lock class occurs at most once in a lock chain so once * we found a match we can break out of this loop.
@@ -4637,8 +4643,7 @@ static void __free_zapped_classes(struct {struct lock_class *class; -if (check_data_structure_consistency) -WARN_ON_ONCE (!check_data_structures ()); +WARN_ON_ONCE (!check_data_structures ());list_for_each_entry (class, &pf->zapped, lock_entry)reinit_class (class);
Quoted 6 lines · Peter Zijlstra
I've gone over all and I think it looks ok now; I'll give it another round tomorrow^Wmonday and then queue bits.
So far the only changes I've made are the below. I'm not entirely sure on the unconditional validity check on
DEBUG_LOCKDEP, maybe I'll add a boot param for that.
Hi Peter,
Please keep in mind that calling check_data_structures() slows down the kernel a lot and also that it makes systems much less responsive. This is because the consistency checks disable interrupts for a long time, up to several seconds. That is why I think it should be possible to enable and disable the consistency checks independent of other kernel config options.
Thanks,
Bart.
Peter Zijlstra
maintainerQuoted 8 lines · Bart Van Assche
Quoted 6 lines · Peter Zijlstra
I've gone over all and I think it looks ok now; I'll give it another round tomorrow^Wmonday and then queue bits.
So far the only changes I've made are the below. I'm not entirely sure on the unconditional validity check on
DEBUG_LOCKDEP, maybe I'll add a boot param for that.
Quoted 7 lines
Hi Peter,
Please keep in mind that calling
check_data_structures()slows down the kernel a lot and also that it makes systems much less responsive. This is because the consistency checks disable interrupts for a long time, up to several seconds. That is why I think it should be possible to enable and disable the consistency checks independent of other kernel config options.
Ah, yes. So I had expected expensive, but hadn't tried it yet.
I'll make it a boot option.