lockdep: Support deadlock detection for recursive read locks
Subsystems (2)
v2 cover lockdep: Support deadlock detection for recursive read locks
Hi Ingo and Peter,
This is V2 for recursive read lock support in lockdep. I fix several bugs in V1 and also add irq inversion detection support for recursive read locks.
V1: https://marc.info/?l=linux-kernel&m=150393341825453
As Peter pointed out:
https://marc.info/?l=linux-kernel&m=150349072023540
The lockdep current has a limit support for recursive read locks, the deadlock case as follow could not be detected:
read_lock(A); lock(B); lock(B); write_lock(A);
I got some inspiration from Gautham R Shenoy:
https://lwn.net/Articles/332801/
, and came up with this series.
The basic idea is:
* Add recursive read locks into the graph
* Classify dependencies into --(RR)-->, --(NR)-->, --(RN)-->,
--(NN)-->, where R stands for recursive read lock, N stands for other locks(i.e. non-recursive read locks and write locks).
* Define strong dependency paths as the paths of dependencies
don't have two adjacent dependencies as --(*R)--> and --(R*)-->.
* Extend __bfs() to only traverse on strong dependency paths.
* If __bfs() finds a strong dependency circle, then a deadlock is
reported.
The whole series is based on current master branch of Linus' tree:
e7d0c41ecc2e ("Merge tag 'devprop-4.14-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm"), and I also put it at:
git://git.kernel.org/pub/scm/linux/kernel/git/boqun/linux.git arr-rfc-v2
The whole series consists of 13 patches:
1. Do a clean up on the return value of __bfs() and its friends.
2. Make __bfs() able to visit every dependency until a match is
found. The old version of __bfs() could only visit each lock class once, and this is insufficient if we are going to add recursive read locks into the dependency graph.
3. Make lock state LOCK_*_READ stand for recursive read lock only
and LOCK_* stand for write lock and non-recursive read lock.
4-5 Extend __bfs() to be able to traverse the stong dependency
patchs after recursive read locks added into the graph.
6-8 Adjust check_redundant(), check_noncircular() and
check_irq_usage() with recursive read locks into consideration.
9. Finally add recursive read locks into the dependency graph.
10-11 Adjust lock cache chain key generation with recursive read locks
into consideration, and provide a test case.
12-13 Add more test cases.
I did pass all the lockdep selftest cases(including those I introduce), and now run it on one of my box, haven't shot my feet yet.
Test and comments are welcome!
Regards,
Boqun
RFC v2 1/13 lockdep: Demagic the return value of BFS
__bfs() could return four magic numbers:
1: search succeeds, but none match.
0: search succeeds, find one match.
-1: search fails because of the cq is full. -2: search fails because a invalid node is found.
This patch cleans things up by making a enum type for the return value of __bfs() and its friends, this improves the code readability of the code, and further, could help if we want to extend the BFS.
--- kernel/locking/lockdep.c | 134 ++++++++++++++++++++++++++++------------------- 1 file changed, 79 insertions(+), 55 deletions(-)
kernel/locking/lockdep.c +79 -55
@@ -996,21 +996,52 @@ static inline int get_lock_depth(struct lock_list *child) }return depth; } +/* +* Return values of a bfs search: +* +* BFS_E* indicates an error +* BFS_R* indicates a result(match or not) +* +* BFS_EINVALIDNODE: Find a invalid node in the graph. +* +* BFS_EQUEUEFULL: The queue is full while doing the bfs. +* +* BFS_RMATCH: Find the matched node in the graph, and put that node * into +* *@target_entry. +* +* BFS_RNOMATCH: Haven't found the matched node and keep *@target_entry +* _unchanged_. +*/ +enum bfs_result { +BFS_EINVALIDNODE =-2 , +BFS_EQUEUEFULL =-1 , +BFS_RMATCH =0 , +BFS_RNOMATCH =1 , +}; + +/* +* bfs_result < 0 means error +*/ + +static inline bool bfs_error (enum bfs_result res) +{ +return res <0 ; +} -static int __bfs (struct lock_list *source_entry, -void *data, -int (*match)(struct lock_list *entry,void *data), -struct lock_list **target_entry, -int forward) +static enum bfs_result __bfs (struct lock_list *source_entry, +void *data, +int (*match)(struct lock_list *entry,void *data), +struct lock_list **target_entry, +int forward) {struct lock_list *entry;struct list_head *head;struct circular_queue *cq = &lock_cq; -int ret =1 ; +enum bfs_result ret =BFS_RNOMATCH ;if (match (source_entry, data)) { *target_entry = source_entry; - ret =0 ; + ret =BFS_RMATCH ; goto exit; }
@@ -1031,7 +1062,7 @@ static int __bfs(struct lock_list *source_entry,__cq_dequeue (cq, (unsigned long *)&lock);if (!lock->class) { - ret =-2 ; + ret =BFS_EINVALIDNODE ; goto exit; }
@@ -1048,12 +1079,12 @@ static int __bfs(struct lock_list *source_entry,mark_lock_accessed (entry, lock);if (match (entry, data)) { *target_entry = entry; - ret =0 ; + ret =BFS_RMATCH ; goto exit; }if (__cq_enqueue (cq, (unsigned long )entry)) { - ret =-1 ; + ret =BFS_EQUEUEFULL ; goto exit; } cq_depth =__cq_get_elem_count (cq);
@@ -1066,19 +1097,21 @@ static int __bfs(struct lock_list *source_entry,return ret; } -static inline int __bfs_forwards (struct lock_list *src_entry, -void *data, -int (*match)(struct lock_list *entry,void *data), -struct lock_list **target_entry) +static inline enum bfs_result +__bfs_forwards (struct lock_list *src_entry, +void *data, +int (*match)(struct lock_list *entry,void *data), +struct lock_list **target_entry) {return __bfs (src_entry, data, match, target_entry,1 ); } -static inline int __bfs_backwards (struct lock_list *src_entry, -void *data, -int (*match)(struct lock_list *entry,void *data), -struct lock_list **target_entry) +static inline enum bfs_result +__bfs_backwards (struct lock_list *src_entry, +void *data, +int (*match)(struct lock_list *entry,void *data), +struct lock_list **target_entry) {return __bfs (src_entry, data, match, target_entry,0 );
@@ -1335,13 +1368,13 @@ unsigned long lockdep_count_backward_deps(struct lock_class *class)/* * Prove that the dependency graph starting at <entry> can not -* lead to <target>. Print an error and return 0 if it does. +* lead to <target>. Print an error and return BFS_RMATCH if it does. */ -static noinline int +static noinline enum bfs_resultcheck_noncircular (struct lock_list *root,struct lock_class *target, -struct lock_list **target_entry) +struct lock_list **target_entry) { -int result; +enum bfs_result result;debug_atomic_inc (nr_cyclic_checks);
@@ -1350,11 +1383,11 @@ check_noncircular(struct lock_list *root, struct lock_class *target,return result; } -static noinline int +static noinline enum bfs_resultcheck_redundant (struct lock_list *root,struct lock_class *target,struct lock_list **target_entry) { -int result; +enum bfs_result result;debug_atomic_inc (nr_redundant_checks);
@@ -1383,15 +1416,12 @@ static inline int usage_match(struct lock_list *entry, void *bit)* * Return 0 if such a node exists in the subgraph, and put that node * into *@target_entry. -* -* Return 1 otherwise and keep *@target_entry unchanged. -* Return <0 on error. */ -static int +static enum bfs_result find_usage_forwards (struct lock_list *root,enum lock_usage_bit bit,struct lock_list **target_entry) { -int result; +enum bfs_result result;debug_atomic_inc (nr_find_usage_forwards_checks);
@@ -1403,18 +1433,12 @@ find_usage_forwards(struct lock_list *root, enum lock_usage_bit bit,/* * Find a node in the backwards-direction dependency sub-graph starting * at @root->class that matches @bit. -* -* Return 0 if such a node exists in the subgraph, and put that node -* into *@target_entry. -* -* Return 1 otherwise and keep *@target_entry unchanged. -* Return <0 on error. */ -static int +static enum bfs_result find_usage_backwards (struct lock_list *root,enum lock_usage_bit bit,struct lock_list **target_entry) { -int result; +enum bfs_result result;debug_atomic_inc (nr_find_usage_backwards_checks);
@@ -1622,18 +1646,18 @@ check_usage(struct task_struct *curr, struct held_lock *prev, this.class =hlock_class (prev); ret =find_usage_backwards (&this, bit_backwards, &target_entry); -if (ret <0 ) +if (bfs_error (ret))return print_bfs_bug (ret); -if (ret ==1 ) -return ret; +if (ret ==BFS_RNOMATCH ) +return 1 ; that.parent =NULL ; that.class =hlock_class (next); ret =find_usage_forwards (&that, bit_forwards, &target_entry1); -if (ret <0 ) +if (bfs_error (ret))return print_bfs_bug (ret); -if (ret ==1 ) -return ret; +if (ret ==BFS_RNOMATCH ) +return 1 ; return print_bad_irq_dependency(curr, &this, &that, target_entry, target_entry1,
@@ -1874,7 +1898,7 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev, int (*save)(struct stack_trace *trace)) {struct lock_list *entry; -int ret; +enum bfs_result ret;struct lock_list this;struct lock_list *uninitialized_var (target_entry );
@@ -1890,9 +1914,9 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev, this.class =hlock_class (next); this.parent =NULL ; ret =check_noncircular (&this,hlock_class (prev), &target_entry); -if (unlikely (!ret)) +if (unlikely (ret ==BFS_RMATCH ))return print_circular_bug (&this, target_entry, next, prev, trace); -else if (unlikely (ret <0 )) +else if (unlikely (bfs_error (ret)))return print_bfs_bug (ret);if (!check_prev_add_irq (curr, prev, next))
@@ -1930,11 +1954,11 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev, this.class =hlock_class (prev); this.parent =NULL ; ret =check_redundant (&this,hlock_class (next), &target_entry); -if (!ret) { +if (ret ==BFS_RMATCH ) {debug_atomic_inc (nr_redundant);return 2 ; } -if (ret <0 ) +if (bfs_error (ret))return print_bfs_bug (ret);
@@ -2685,16 +2709,16 @@ static int check_usage_forwards(struct task_struct *curr, struct held_lock *this, enum lock_usage_bit bit, const char *irqclass) { - int ret; + enum bfs_result ret;struct lock_list root;struct lock_list *uninitialized_var (target_entry ); root.parent =NULL ; root.class =hlock_class (this); ret =find_usage_forwards (&root, bit, &target_entry); -if (ret <0 ) +if (bfs_error (ret))return print_bfs_bug (ret); -if (ret ==1 ) +if (ret ==BFS_RNOMATCH )return ret; return print_irq_inversion_bug(curr, &root, target_entry,
@@ -2709,17 +2733,17 @@ static int check_usage_backwards(struct task_struct *curr, struct held_lock *this, enum lock_usage_bit bit, const char *irqclass) { - int ret; + enum bfs_result ret;struct lock_list root;struct lock_list *uninitialized_var (target_entry ); root.parent =NULL ; root.class =hlock_class (this); ret =find_usage_backwards (&root, bit, &target_entry); -if (ret <0 ) +if (bfs_error (ret))return print_bfs_bug (ret); -if (ret ==1 ) -return ret; +if (ret ==BFS_RNOMATCH ) +return 1 ;return print_irq_inversion_bug (curr, &root, target_entry, this,0 , irqclass);
Signature · 1 line
2.14.1
RFC v2 2/13 lockdep: Make __bfs() visit every dependency rather than every class until a match
In reply to Boqun FengCurrently, __bfs() will do a breadth-first search in the dependency graph and visit each lock class in the graph exactly once, so for example, in the following graph:
A ---------> B | ^ | | +----------> C
a __bfs() call starts at A, will visit B through dependency A -> B and visit C through dependency C -> B and that's it.
This is OK for now, as we only have strong dependencies in the dependency graph, so whenever there is a traverse path from A to B in __bfs(), it means A has strong dependency to B(IOW, B depends on A). So no need to visit all dependencies in the graph.
However, as we are going to add recursive-read lock into the dependency graph, not all the paths mean strong dependencies afterwards, in the same example above, dependency A --> B may be a weak dependency and traverse A -> C -> B may be a strong dependency path. So now we need to visit each dependency in the graph once in __bfs() until a match.
The solution is simple:
We used to mark lock_class::lockdep_dependency_gen_id to indicate a class has been visited in __bfs(), now we change the semantics a little bit, we now mark lock_class::lockdep_dependency_gen_id to indicate all the dependencies in its lock_{after,before} have been visited in the __bfs(), note we only take one direction in a __bfs() search. In this way, each dependency is guaranteed to be visited until we find a match.
--- kernel/locking/lockdep.c | 61 +++++++++++++++++++++++++++--------------------- 1 file changed, 34 insertions(+), 27 deletions(-)
kernel/locking/lockdep.c +34 -27
@@ -960,24 +960,20 @@ static inline unsigned int __cq_get_elem_count(struct circular_queue *cq)return (cq->rear - cq->front) &CQ_MASK ; } -static inline void mark_lock_accessed (struct lock_list *lock, -struct lock_list *parent) +static inline void mark_lock_list_accessed (struct lock_class *class) { -unsigned long nr; + class->dep_gen_id = lockdep_dependency_gen_id; +} - nr = lock - list_entries; -WARN_ON (nr >= nr_list_entries);/* Out-of-bounds, input fail */ +static inline void visit_lock_entry (struct lock_list *lock, +struct lock_list *parent) +{ lock->parent = parent; - lock->class->dep_gen_id = lockdep_dependency_gen_id; } -static inline unsigned long lock_accessed (struct lock_list *lock) +static inline unsigned long lock_list_accessed (struct lock_class *class) { -unsigned long nr; - - nr = lock - list_entries; -WARN_ON (nr >= nr_list_entries);/* Out-of-bounds, input fail */ -return lock->class->dep_gen_id == lockdep_dependency_gen_id; +return class->dep_gen_id == lockdep_dependency_gen_id; }static inline struct lock_list *get_lock_parent (struct lock_list *child)
@@ -1066,6 +1062,18 @@ static enum bfs_result __bfs(struct lock_list *source_entry, goto exit; } +/* +* If we have visited all the dependencies from this @lock to +* others(iow, if we have visited all lock_list entries in +* @lock->class->locks_{after,before}, we skip, otherwise go +* and visit all the dependencies in the list and mark this +* list accessed. +*/ +if (lock_list_accessed (lock->class)) +continue ; +else +mark_lock_list_accessed (lock->class); +if (forward) head = &lock->class->locks_after;else
@@ -1074,23 +1082,22 @@ static enum bfs_result __bfs(struct lock_list *source_entry,DEBUG_LOCKS_WARN_ON (!irqs_disabled ());list_for_each_entry_rcu (entry, head, entry) { -if (!lock_accessed (entry)) { -unsigned int cq_depth; -mark_lock_accessed (entry, lock); -if (match (entry, data)) { - *target_entry = entry; - ret =BFS_RMATCH ; - goto exit; - } +unsigned int cq_depth; -if (__cq_enqueue (cq, (unsigned long )entry)) { - ret =BFS_EQUEUEFULL ; - goto exit; - } - cq_depth =__cq_get_elem_count (cq); -if (max_bfs_queue_depth < cq_depth) - max_bfs_queue_depth = cq_depth; +visit_lock_entry (entry, lock); +if (match (entry, data)) { + *target_entry = entry; + ret =BFS_RMATCH ; + goto exit; + } + +if (__cq_enqueue (cq, (unsigned long )entry)) { + ret =BFS_EQUEUEFULL ; + goto exit; } + cq_depth =__cq_get_elem_count (cq); +if (max_bfs_queue_depth < cq_depth) + max_bfs_queue_depth = cq_depth; } } exit:
Signature · 1 line
2.14.1
RFC v2 3/13 lockdep: Change the meanings of LOCK_{USED_IN, ENABLED}_*_{READ}
In reply to Boqun FengWe have three types of lock acquisitions: write, non-recursive read and recursive read, and write and non-recursive read have no difference from a viewpoint for deadlock detections, because a write acquisition of the corresponding lock on an independent CPU or task makes a non-recursive lock a write lock. So we could treat them as same types in lockdep(for example, we can call them as non-recursive locks).
As to the irq lock inversion detection(safe->unsafe deadlock detection), we used to differ write lock with read lock(non-recursive and recursive), such a classification could be improved as non-recursive read lock behaves the same as write lock, so this patch changes the meanings of LOCK_{USED_IN, ENABLED}_*_{READ}.
old:
LOCK_* : stands for write lock
LOCK_*_READ: stands for read lock(non-recursive and recursive)
new:
LOCK_* : stands for non-recursive(write lock and non-recursive read lock)
LOCK_*_READ: stands for recursive read lock
(The names of them should be changed too to avoid confusion, so are the related printks, however, this patch is simply for an RFC purpose without too many unrelated changes, in the future, I could either add necessary changes in next versions or leave those as TODOs)
Such a change is needed for a future improvement on recursive read related irq inversion deadlock detection.
--- kernel/locking/lockdep.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
kernel/locking/lockdep.c +2 -2
@@ -3091,7 +3091,7 @@ static int mark_irqflags(struct task_struct *curr, struct held_lock *hlock)* mark the lock as used in these contexts: */ if (!hlock->trylock) { -if (hlock->read) { +if (hlock->read ==2 ) {if (curr->hardirq_context)if (!mark_lock (curr, hlock,LOCK_USED_IN_HARDIRQ_READ ))
@@ -3110,7 +3110,7 @@ static int mark_irqflags(struct task_struct *curr, struct held_lock *hlock) } }if (!hlock->hardirqs_off) { -if (hlock->read) { +if (hlock->read ==2 ) {if (!mark_lock (curr, hlock,LOCK_ENABLED_HARDIRQ_READ ))return 0 ;
Signature · 1 line
2.14.1
RFC v2 4/13 lockdep: Introduce lock_list::dep
In reply to Boqun FengTo add recursive read locks into the dependency graph, we need to store the types of dependencies for the BFS later. There are four kinds of dependencies:
* Non-recursive -> Non-recursive dependencies(NN)
e.g. write_lock(prev) -> write_lock(next)
* Recursive -> Non-recursive dependencies(RN)
e.g. read_lock(prev) -> write_lock(next);
* Non-recursive -> recursive dependencies(NR)
e.g. write_lock(prev) -> read_lock(next);
* Recursive -> recursive dependencies(RR)
e.g. read_lock(prev) -> read_lock(next);
Given a pair of two locks, four kinds of dependencies could all exist between them, so we use 4 bit for the presence of each kind(stored in lock_list::dep).
--- include/linux/lockdep.h | 2 ++ kernel/locking/lockdep.c | 46 ++++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 46 insertions(+), 2 deletions(-)
include/linux/lockdep.h +2 -0
@@ -192,6 +192,8 @@ struct lock_list {struct lock_class *class;struct stack_trace trace;int distance; +/* bitmap of different dependencies from head to this */ +u16 dep;/* * The parent field is used to implement breadth-first search, and the
kernel/locking/lockdep.c +44 -2
76 lines not on this page · raw message
Signature · 1 line
2.14.1
RFC v2 5/13 lockdep: Extend __bfs() to work with multiple kinds of dependencies
In reply to Boqun FengNow we have four kinds of dependencies in the dependency graph, and not all the pathes carry strong dependencies, for example:
Given lock A, B, C, if we have: CPU1 CPU2 ============= ============== write_lock(A); read_lock(B); read_lock(B); write_lock(C); then we have dependencies A--(NR)-->B, and B-->(RN)-->C, (NR and RN to indicate the dependency kind), A actually doesn't have strong dependency to C(IOW, C doesn't depend on A), to see this, let's say we have a third CPU3 doing: CPU3: ============= write_lock(C); write_lock(A); , this is not a deadlock. However if we change the read_lock() on CPU2 to a write_lock(), it's a deadlock then. So A-->(NR)-->B-->(RN)-->C is not a strong dependency but A-->(NR)--B-->(NN)-->C is a strong dependency.
We can generalize this as: If a path of dependencies doesn't have two adjacent dependencies as (*R)--L-->(R*), where L is some lock, it is a strong dependency path, otherwise it's not.
Now our mission is to make __bfs() traverse only the strong dependency paths, which is simple: we record whether we have --(*R)--> at the current tail of the path in lock_list::is_rr, and whenever we pick a dependency in the traverse, we 1) make sure we don't pick a --(R*)--> dependency if our current tail is --(*R)--> and 2) greedily pick a --(*N)--> as hard as possible.
With this extension for __bfs(), we now only need to initialize the root of __bfs() properly(with a correct ->is_rr), to do so, we introduce some helper functions, which also cleans up a little bit for the __bfs() root initialization code.
--- include/linux/lockdep.h | 2 ++ kernel/locking/lockdep.c | 85 +++++++++++++++++++++++++++++++++++++----------- 2 files changed, 68 insertions(+), 19 deletions(-)
include/linux/lockdep.h +2 -0
@@ -194,6 +194,8 @@ struct lock_list {int distance;/* bitmap of different dependencies from head to this */ u16 dep; +/* used by BFS to record whether this is picked as a recursive read */ +u16 is_rr;/* * The parent field is used to implement breadth-first search, and the
kernel/locking/lockdep.c +66 -19
162 lines not on this page · raw message
Signature · 1 line
2.14.1
RFC v2 6/13 lockdep: Adjust check_redundant() for recursive read change
In reply to Boqun FengAs we have four kinds of dependencies now, check_redundant() should only report redundant if we have a dependency path which is equal or _stronger_ than the current dependency. For example if check_prev_add() we have:
prev->read == 2 && next->read != 2
, we should only report redundant if we find a path like:
prev--(RN)-->....--(*N)-->next
and if we have:
prev->read == 2 && next->read == 2
, we could report redundant if we find a path like:
prev--(RN)-->....--(*N)-->next
or
prev--(RN)-->....--(*R)-->next
To do so, we need to pass the recursive-read status of next into check_redundant(). This patch changes the parameter of check_redundant() and the match function to achieve this.
--- kernel/locking/lockdep.c | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-)
kernel/locking/lockdep.c +8 -5
@@ -1337,9 +1337,12 @@ print_circular_bug_header(struct lock_list *entry, unsigned int depth,return 0 ; } -static inline int class_equal (struct lock_list *entry,void *data) +static inline int hlock_equal (struct lock_list *entry,void *data) { -return entry->class == data; +struct held_lock *hlock = (struct held_lock *)data; + +return hlock_class (hlock) == entry->class && + (hlock->read ==2 || !entry->is_rr); } static noinline int print_circular_bug(struct lock_list *this,
@@ -1473,14 +1476,14 @@ check_noncircular(struct lock_list *root, struct lock_class *target, } static noinline enum bfs_result -check_redundant (struct lock_list *root,struct lock_class *target, +check_redundant (struct lock_list *root,struct held_lock *target,struct lock_list **target_entry) {enum bfs_result result;debug_atomic_inc (nr_redundant_checks); - result =__bfs_forwards (root, target, class_equal, target_entry); + result =__bfs_forwards (root, target, hlock_equal, target_entry);return result; }
@@ -2047,7 +2050,7 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev,* Is the <prev> -> <next> link redundant? */ bfs_init_root (&this, prev); - ret =check_redundant (&this,hlock_class (next), &target_entry); + ret =check_redundant (&this, next, &target_entry);if (ret ==BFS_RMATCH ) {debug_atomic_inc (nr_redundant);return 2 ;
Signature · 1 line
2.14.1
RFC v2 7/13 lockdep: Support deadlock detection for recursive read in check_noncircular()
In reply to Boqun FengCurrently, lockdep only has limit support for deadlock detection for recursive read locks.
The basic idea of the detection is:
Since we make __bfs() able to traverse only the strong dependency paths, so we report a circular deadlock if we could find a circle of a strong dependency path.
--- kernel/locking/lockdep.c | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-)
kernel/locking/lockdep.c +11 -3
@@ -1345,6 +1345,14 @@ static inline int hlock_equal(struct lock_list *entry, void *data) (hlock->read ==2 || !entry->is_rr); } +static inline int hlock_conflict (struct lock_list *entry,void *data) +{ +struct held_lock *hlock = (struct held_lock *)data; + +return hlock_class (hlock) == entry->class && + (hlock->read !=2 || !entry->is_rr); +} + static noinline int print_circular_bug(struct lock_list *this, struct lock_list *target, struct held_lock *check_src,
@@ -1459,18 +1467,18 @@ unsigned long lockdep_count_backward_deps(struct lock_class *class) }/* -* Prove that the dependency graph starting at <entry> can not +* Prove that the dependency graph starting at <root> can not * lead to <target>. Print an error and return BFS_RMATCH if it does. */ static noinline enum bfs_result -check_noncircular (struct lock_list *root,struct lock_class *target, +check_noncircular (struct lock_list *root,struct held_lock *target,struct lock_list **target_entry) {enum bfs_result result;debug_atomic_inc (nr_cyclic_checks); - result =__bfs_forwards (root, target, class_equal, target_entry); + result =__bfs_forwards (root, target, hlock_conflict, target_entry);return result; }
Signature · 1 line
2.14.1
RFC v2 8/13 lockdep: Fix recursive read lock related safe->unsafe detection
In reply to Boqun FengThere are four cases for recursive read lock realted deadlocks:
(--(X..Y)--> means a strong dependency path starts with a --(X*)--> dependency and ends with a --(*Y)-- dependency.)
1. An irq-safe lock L1 has a dependency --(*..*)--> to an
irq-unsafe lock L2.
2. An irq-read-safe lock L1 has a dependency --(N..*)--> to an
irq-unsafe lock L2.
3. An irq-safe lock L1 has a dependency --(*..N)--> to an
irq-read-unsafe lock L2.
4. An irq-read-safe lock L1 has a dependency --(N..N)--> to an
irq-read-unsafe lock L2.
The current check_usage() only checks 1) and 2), so this patch adds checks for 3) and 4) and makes sure when find_usage_{back,for}wards find an irq-read-{,un}safe lock, the traverse path should ends at a dependency --(*N)-->. Note when we search backwards, --(*N)--> indicates a real dependency --(N*)-->.
--- kernel/locking/lockdep.c | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-)
kernel/locking/lockdep.c +16 -1
@@ -1505,7 +1505,14 @@ check_redundant(struct lock_list *root, struct held_lock *target,static inline int usage_match (struct lock_list *entry,void *bit) { -return entry->class->usage_mask & (1 << (enum lock_usage_bit )bit); +enum lock_usage_bit ub = (enum lock_usage_bit )bit; + + +if (ub &1 ) +return entry->class->usage_mask & (1 << ub) && + !entry->is_rr; +else +return entry->class->usage_mask & (1 << ub); }
@@ -1816,6 +1823,10 @@ static int check_irq_usage(struct task_struct *curr, struct held_lock *prev, exclusive_bit(bit), state_name(bit)))return 0 ; +if (!check_usage (curr, prev, next, bit, +exclusive_bit (bit) +1 ,state_name (bit))) +return 0 ; + bit++;/* _READ */ /*
@@ -1828,6 +1839,10 @@ static int check_irq_usage(struct task_struct *curr, struct held_lock *prev, exclusive_bit(bit), state_name(bit)))return 0 ; +if (!check_usage (curr, prev, next, bit, +exclusive_bit (bit) +1 ,state_name (bit))) +return 0 ; +return 1 ; }
Signature · 1 line
2.14.1
RFC v2 9/13 lockdep: Add recursive read locks into dependency graph
In reply to Boqun FengSince we have all the fundamental to handle recursive read locks, we now add them into the dependency graph.
--- kernel/locking/lockdep.c | 16 +++------------- 1 file changed, 3 insertions(+), 13 deletions(-)
kernel/locking/lockdep.c +3 -13
@@ -2033,16 +2033,6 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev,if (!check_prev_add_irq (curr, prev, next))return 0 ; -/* -* For recursive read-locks we do all the dependency checks, -* but we dont store read-triggered dependencies (only -* write-triggered dependencies). This ensures that only the -* write-side dependencies matter, and that if for example a -* write-lock never takes any other locks, then the reads are -* equivalent to a NOP. -*/ -if (next->read ==2 || prev->read ==2 ) -return 1 ;/* * Is the <prev> -> <next> dependency already present? *
@@ -2164,7 +2154,7 @@ check_prevs_add(struct task_struct *curr, struct held_lock *next)* Only non-recursive-read entries get new dependencies * added: */ -if (hlock->read !=2 && hlock->check) { +if (hlock->check) {int ret =check_prev_add (curr, hlock, next, distance, &trace, save);if (!ret)
@@ -4965,7 +4955,7 @@ static inline struct lock_class *xlock_class(struct cross_lock *xlock)*/ static inline int depend_before (struct held_lock *hlock) { -return hlock->read !=2 && hlock->check && !hlock->trylock; +return hlock->check && !hlock->trylock; }/*
@@ -4973,7 +4963,7 @@ static inline int depend_before(struct held_lock *hlock)*/ static inline int depend_after (struct held_lock *hlock) { -return hlock->read !=2 && hlock->check; +return hlock->check; }/*
Signature · 1 line
2.14.1
RFC v2 10/13 lockdep/selftest: Add a R-L/L-W test case specific to chain cache behavior
In reply to Boqun FengAs our chain cache doesn't differ read/write locks, so even we can detect a read-lock/lock-write deadlock in check_noncircular(), we can still be fooled if a read-lock/lock-read case(which is not a deadlock) comes first.
So introduce this test case to test specific to the chain cache behavior on detecting recursive read lock related deadlocks.
--- lib/locking-selftest.c | 47 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+)
lib/locking-selftest.c +47 -0
@@ -394,6 +394,49 @@ static void rwsem_ABBA1(void)MU (Y1 );// should fail } +/* +* read_lock(A) +* spin_lock(B) +* spin_lock(B) +* write_lock(A) +* +* This test case is aimed at poking whether the chain cache prevents us from +* detecting a read-lock/lock-write deadlock: if the chain cache doesn't differ +* read/write locks, the following case may happen +* +* { read_lock(A)->lock(B) dependency exists } +* +* P0: +* lock(B); +* read_lock(A); +* +* { Not a deadlock, B -> A is added in the chain cache } +* +* P1: +* lock(B); +* write_lock(A); +* +* { B->A found in chain cache, not reported as a deadlock } +* +*/ +static void rlock_chaincache_ABBA1 (void ) +{ +RL (X1 ); +L (Y1 ); +U (Y1 ); +RU (X1 ); + +L (Y1 ); +RL (X1 ); +RU (X1 ); +U (Y1 ); + +L (Y1 ); +WL (X1 ); +WU (X1 ); +U (Y1 );// should fail +} +/* * read_lock(A) * spin_lock(B)
@@ -2052,6 +2095,10 @@ void locking_selftest(void)pr_cont (" |" );dotest (rwsem_ABBA3,FAILURE ,LOCKTYPE_RWSEM ); +print_testname ("chain cached mixed R-L/L-W ABBA" ); +pr_cont (" |" ); +dotest (rlock_chaincache_ABBA1,FAILURE ,LOCKTYPE_RWLOCK ); +printk (" --------------------------------------------------------------------------\n" );/*
Signature · 1 line
2.14.1
RFC v2 11/13 lockdep: Take read/write status in consideration when generate chainkey
In reply to Boqun FengCurrently, the chainkey of a lock chain is a hash sum of the class_idx of all the held locks, the read/write status are not taken in to consideration while generating the chainkey. This could result into a problem, if we have:
P1()
{
read_lock(B);
lock(A);
}
P2()
{
lock(A);
read_lock(B);
}
P3()
{
lock(A);
write_lock(B);
}, and P1(), P2(), P3() run one by one, when running P2(), it's detected such a lock chain A -> B is not a deadlock, then it's added in the chain cache, and then when running P3(), even if it's a deadlock, we could miss it because of the hit of chain cache. This could be confirmed by self testcase "chain cached mixed R-L/L-W ".
To resolve this, we use "hlock_id" to generate the chainkey, the hlock_id is a tuple (hlock->class_idx, hlock->read), which fits in a u16 type. With this, the chainkeys are different is the lock sequences have the same locks but different read/write status.
Besides, since we use "hlock_id" to generate chainkeys, the chain_hlocks now store the "hlock_id"s rather than lock_class indexes.
--- kernel/locking/lockdep.c | 60 ++++++++++++++++++++++++++++++------------------ 1 file changed, 38 insertions(+), 22 deletions(-)
kernel/locking/lockdep.c +38 -22
@@ -311,6 +311,21 @@ static struct hlist_head classhash_table[CLASSHASH_SIZE];static struct hlist_head chainhash_table[CHAINHASH_SIZE ]; +/* +* the id chain_hlocks +*/ +static inline u16 hlock_id (struct held_lock *hlock) +{ +BUILD_BUG_ON (MAX_LOCKDEP_KEYS_BITS +2 >16 ); + +return (hlock->class_idx | (hlock->read <<MAX_LOCKDEP_KEYS_BITS )); +} + +static inline unsigned int chain_hlock_class_idx (u16 hlock_id) +{ +return hlock_id &MAX_LOCKDEP_KEYS ; +} +/* * The hash key of the lock dependency chains is a hash itself too: * it's a hash of all locks taken up to that lock, including that lock.
@@ -2212,7 +2227,10 @@ static u16 chain_hlocks[MAX_LOCKDEP_CHAIN_HLOCKS];struct lock_class *lock_chain_get_class (struct lock_chain *chain,int i) { -return lock_classes + chain_hlocks[chain->base + i]; +u16 chain_hlock = chain_hlocks[chain->base + i]; +unsigned int class_idx =chain_hlock_class_idx (chain_hlock); + +return lock_classes + class_idx -1 ; }/*
@@ -2238,12 +2256,12 @@ static inline int get_first_held_lock(struct task_struct *curr,/* * Returns the next chain_key iteration */ -static u64 print_chain_key_iteration (int class_idx,u64 chain_key) +static u64 print_chain_key_iteration (u16 hlock_id,u64 chain_key) { -u64 new_chain_key =iterate_chain_key (chain_key, class_idx); +u64 new_chain_key =iterate_chain_key (chain_key, hlock_id); -printk (" class_idx:%d -> chain_key:%016Lx" , - class_idx, +printk (" hlock_id:%d -> chain_key:%016Lx" , + (unsigned int )hlock_id, (unsigned long long )new_chain_key);return new_chain_key; }
@@ -2259,12 +2277,12 @@ print_chain_keys_held_locks(struct task_struct *curr, struct held_lock *hlock_neprintk ("depth: %u\n" , depth +1 );for (i =get_first_held_lock (curr, hlock_next); i < depth; i++) { hlock = curr->held_locks + i; - chain_key =print_chain_key_iteration (hlock->class_idx, chain_key); + chain_key =print_chain_key_iteration (hlock_id (hlock), chain_key);print_lock (hlock); } -print_chain_key_iteration (hlock_next->class_idx, chain_key); +print_chain_key_iteration (hlock_id (hlock_next), chain_key);print_lock (hlock_next); }
@@ -2272,14 +2290,14 @@ static void print_chain_keys_chain(struct lock_chain *chain) {int i;u64 chain_key =0 ; -int class_id; +u16 hlock_id;printk ("depth: %u\n" , chain->depth);for (i =0 ; i < chain->depth; i++) { - class_id = chain_hlocks[chain->base + i]; - chain_key =print_chain_key_iteration (class_id +1 , chain_key); + hlock_id = chain_hlocks[chain->base + i]; + chain_key =print_chain_key_iteration (hlock_id, chain_key); -print_lock_name (lock_classes + class_id); +print_lock_name (lock_classes +chain_hlock_class_idx (hlock_id) -1 );printk ("\n" ); } }
@@ -2328,7 +2346,7 @@ static int check_no_collision(struct task_struct *curr, }for (j =0 ; j < chain->depth -1 ; j++, i++) { - id = curr->held_locks[i].class_idx -1 ; + id =hlock_id (&curr->held_locks[i]);if (DEBUG_LOCKS_WARN_ON (chain_hlocks[chain->base + j] != id)) {print_collision (curr, hlock, chain);
@@ -2385,8 +2403,8 @@ static inline int add_chain_cache_classes(unsigned int prev,if (likely (nr_chain_hlocks + chain->depth <=MAX_LOCKDEP_CHAIN_HLOCKS )) { chain->base = nr_chain_hlocks; nr_chain_hlocks += chain->depth; - chain_hlocks[chain->base] = prev -1 ; - chain_hlocks[chain->base +1 ] = next -1 ; + chain_hlocks[chain->base] = prev; + chain_hlocks[chain->base +1 ] = next; }#ifdef CONFIG_DEBUG_LOCKDEP /*
@@ -2420,7 +2438,6 @@ static inline int add_chain_cache(struct task_struct *curr, struct held_lock *hlock, u64 chain_key) { -struct lock_class *class =hlock_class (hlock);struct hlist_head *hash_head =chainhashentry (chain_key);struct lock_chain *chain;int i, j;
@@ -2459,10 +2476,9 @@ static inline int add_chain_cache(struct task_struct *curr,if (likely (nr_chain_hlocks + chain->depth <=MAX_LOCKDEP_CHAIN_HLOCKS )) { chain->base = nr_chain_hlocks;for (j =0 ; j < chain->depth -1 ; j++, i++) { -int lock_id = curr->held_locks[i].class_idx -1 ; - chain_hlocks[chain->base + j] = lock_id; + chain_hlocks[chain->base + j] =hlock_id (&curr->held_locks[i]); } - chain_hlocks[chain->base + j] = class - lock_classes; + chain_hlocks[chain->base + j] =hlock_id (hlock); }if (nr_chain_hlocks <MAX_LOCKDEP_CHAIN_HLOCKS )
@@ -2660,7 +2676,7 @@ static void check_chain_key(struct task_struct *curr)if (prev_hlock && (prev_hlock->irq_context != hlock->irq_context)) chain_key =0 ; - chain_key =iterate_chain_key (chain_key, hlock->class_idx); + chain_key =iterate_chain_key (chain_key,hlock_id (hlock)); prev_hlock = hlock; }if (chain_key != curr->curr_chain_key) {
@@ -3626,7 +3642,7 @@ static int __lock_acquire(struct lockdep_map *lock, unsigned int subclass, chain_key =0 ; chain_head =1 ; } - chain_key =iterate_chain_key (chain_key, class_idx); + chain_key =iterate_chain_key (chain_key,hlock_id (hlock));if (nest_lock && !__lock_is_held (nest_lock,-1 ))return print_lock_nested_lock_not_held (curr, hlock, ip);
@@ -5136,9 +5152,9 @@ static int commit_xhlock(struct cross_lock *xlock, struct hist_lock *xhlock)unsigned int xid, pid;u64 chain_key; - xid =xlock_class (xlock) - lock_classes; + xid =xlock_class (xlock) - lock_classes +1 ; chain_key =iterate_chain_key ((u64 )0 , xid); - pid =xhlock_class (xhlock) - lock_classes; + pid =xhlock_class (xhlock) - lock_classes +1 ; chain_key =iterate_chain_key (chain_key, pid);if (lookup_chain_cache (chain_key))
Signature · 1 line
2.14.1
RFC v2 12/13 lockdep/selftest: Unleash irq_read_recursion2 and add more
In reply to Boqun FengNow since we can handle recursive read related irq inversion deadlocks correctly, uncomment the irq_read_recursion2 and add more testcases.
--- lib/locking-selftest.c | 59 ++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 47 insertions(+), 12 deletions(-)
lib/locking-selftest.c +47 -12
@@ -1051,20 +1051,28 @@ GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_wlock)#define E3 () \ \ IRQ_ENTER(); \ - RL(A); \ + LOCK(A); \ L(B); \ U(B); \ - RU(A); \ + UNLOCK(A); \ IRQ_EXIT();/* -* Generate 12 testcases: +* Generate 24 testcases: */ #include "locking-selftest-hardirq.h" -GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_hard) +#include "locking-selftest-rlock.h" +GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_hard_rlock) + +#include "locking-selftest-wlock.h" +GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_hard_wlock)#include "locking-selftest-softirq.h" -GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_soft) +#include "locking-selftest-rlock.h" +GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_soft_rlock) + +#include "locking-selftest-wlock.h" +GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_soft_wlock)#undef E1#undef E2
@@ -1078,8 +1086,8 @@ GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_soft) \IRQ_DISABLE (); \L (B ); \ -WL (A ); \ -WU (A ); \ +LOCK (A ); \ +UNLOCK (A ); \U (B ); \IRQ_ENABLE ();
@@ -1096,13 +1104,21 @@ GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_soft)IRQ_EXIT ();/* -* Generate 12 testcases: +* Generate 24 testcases: */ #include "locking-selftest-hardirq.h" -// GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_hard) +#include "locking-selftest-rlock.h" +GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_hard_rlock) + +#include "locking-selftest-wlock.h" +GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_hard_wlock)#include "locking-selftest-softirq.h" -// GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_soft) +#include "locking-selftest-rlock.h" +GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_soft_rlock) + +#include "locking-selftest-wlock.h" +GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_soft_wlock)#ifdef CONFIG_DEBUG_LOCK_ALLOC # define I_SPINLOCK (x) lockdep_reset_lock(&lock_##x.dep_map)
@@ -1255,6 +1271,25 @@ static inline void print_testname(const char *testname) dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK); \ pr_cont("\n"); +#define DO_TESTCASE_2RW (desc, name, nr) \ + print_testname(desc"/"#nr); \ + pr_cont(" |"); \ + dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK); \ + dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK); \ + pr_cont("\n"); + +#define DO_TESTCASE_2x2RW (desc, name, nr) \ + DO_TESTCASE_2RW("hard-"desc, name##_hard, nr) \ + DO_TESTCASE_2RW("soft-"desc, name##_soft, nr) \ + +#define DO_TESTCASE_6x2x2RW (desc, name) \ + DO_TESTCASE_2x2RW(desc, name, 123); \ + DO_TESTCASE_2x2RW(desc, name, 132); \ + DO_TESTCASE_2x2RW(desc, name, 213); \ + DO_TESTCASE_2x2RW(desc, name, 231); \ + DO_TESTCASE_2x2RW(desc, name, 312); \ + DO_TESTCASE_2x2RW(desc, name, 321); +#define DO_TESTCASE_6 (desc, name) \ print_testname(desc); \ dotest(name##_spin, FAILURE, LOCKTYPE_SPIN); \
@@ -2111,8 +2146,8 @@ void locking_selftest(void)DO_TESTCASE_6x6 ("safe-A + unsafe-B #2" , irqsafe4);DO_TESTCASE_6x6RW ("irq lock-inversion" , irq_inversion); -DO_TESTCASE_6x2 ("irq read-recursion" , irq_read_recursion); -// DO_TESTCASE_6x2B("irq read-recursion #2", irq_read_recursion2); +DO_TESTCASE_6x2x2RW ("irq read-recursion" , irq_read_recursion); +DO_TESTCASE_6x2x2RW ("irq read-recursion #2" , irq_read_recursion2);ww_tests ();
Signature · 1 line
2.14.1
RFC v2 13/13 lockdep/selftest: Add more recursive read related test cases
In reply to Boqun FengAdd those four test cases:
1.
CPU1 CPU2 CPU3 ============= ============= ============= write_lock(X); write_lock(Y); write_lock(Z); read_lock(Y); read_lock(Z); read_lock(X); deadlock.
2.
CPU1 CPU2 CPU3 ============= ============= ============= write_lock(X); read_lock(Y); write_lock(Z); write_lock(Y); read_lock(Z); read_lock(X); deadlock.
3.
CPU1 CPU2 CPU3 ============= ============= ============= write_lock(X); read_lock(Y); read_lock(Z); write_lock(Y); read_lock(Z); write_lock(X); not deadlock.
4.
CPU1 CPU2 CPU3 ============= ============= ============= write_lock(X); read_lock(Y); write_lock(Z); read_lock(Y); read_lock(Z); write_lock(X); not deadlock.
Those self testcases are valuable for the development of supporting recursive read related deadlock detection.
--- lib/locking-selftest.c | 161 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 161 insertions(+)
lib/locking-selftest.c +161 -0
@@ -1032,6 +1032,133 @@ GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_wlock)#undef E2#undef E3 +/* +* write-read / write-read / write-read deadlock even if read is recursive +*/ + +#define E1 () \ + \ + WL(X1); \ + RL(Y1); \ + RU(Y1); \ + WU(X1); + +#define E2 () \ + \ + WL(Y1); \ + RL(Z1); \ + RU(Z1); \ + WU(Y1); + +#define E3 () \ + \ + WL(Z1); \ + RL(X1); \ + RU(X1); \ + WU(Z1); + +#include "locking-selftest-rlock.h" +GENERATE_PERMUTATIONS_3_EVENTS(W1R2_W2R3_W3R1) + +#undef E1 +#undef E2 +#undef E3 + +/* +* write-write / read-read / write-read deadlock even if read is recursive +*/ + +#define E1 () \ + \ + WL(X1); \ + WL(Y1); \ + WU(Y1); \ + WU(X1); + +#define E2 () \ + \ + RL(Y1); \ + RL(Z1); \ + RU(Z1); \ + RU(Y1); + +#define E3 () \ + \ + WL(Z1); \ + RL(X1); \ + RU(X1); \ + WU(Z1); + +#include "locking-selftest-rlock.h" +GENERATE_PERMUTATIONS_3_EVENTS(W1W2_R2R3_W3R1) + +#undef E1 +#undef E2 +#undef E3 + +/* +* write-write / read-read / read-write is not deadlock when read is recursive +*/ + +#define E1 () \ + \ + WL(X1); \ + WL(Y1); \ + WU(Y1); \ + WU(X1); + +#define E2 () \ + \ + RL(Y1); \ + RL(Z1); \ + RU(Z1); \ + RU(Y1); + +#define E3 () \ + \ + RL(Z1); \ + WL(X1); \ + WU(X1); \ + RU(Z1); + +#include "locking-selftest-rlock.h" +GENERATE_PERMUTATIONS_3_EVENTS(W1R2_R2R3_W3W1) + +#undef E1 +#undef E2 +#undef E3 + +/* +* write-read / read-read / write-write is not deadlock when read is recursive +*/ + +#define E1 () \ + \ + WL(X1); \ + RL(Y1); \ + RU(Y1); \ + WU(X1); + +#define E2 () \ + \ + RL(Y1); \ + RL(Z1); \ + RU(Z1); \ + RU(Y1); + +#define E3 () \ + \ + WL(Z1); \ + WL(X1); \ + WU(X1); \ + WU(Z1); + +#include "locking-selftest-rlock.h" +GENERATE_PERMUTATIONS_3_EVENTS(W1W2_R2R3_R3W1) + +#undef E1 +#undef E2 +#undef E3/* * read-lock / write-lock recursion that is actually safe. */
@@ -1257,6 +1384,19 @@ static inline void print_testname(const char *testname) dotest(name##_##nr, FAILURE, LOCKTYPE_RWLOCK); \ pr_cont("\n"); +#define DO_TESTCASE_1RR (desc, name, nr) \ + print_testname(desc"/"#nr); \ + pr_cont(" |"); \ + dotest(name##_##nr, SUCCESS, LOCKTYPE_RWLOCK); \ + pr_cont("\n"); + +#define DO_TESTCASE_1RRB (desc, name, nr) \ + print_testname(desc"/"#nr); \ + pr_cont(" |"); \ + dotest(name##_##nr, FAILURE, LOCKTYPE_RWLOCK); \ + pr_cont("\n"); + +#define DO_TESTCASE_3 (desc, name, nr) \ print_testname(desc"/"#nr); \ dotest(name##_spin_##nr, FAILURE, LOCKTYPE_SPIN); \
@@ -1366,6 +1506,22 @@ static inline void print_testname(const char *testname)DO_TESTCASE_2IB (desc, name,312 ); \DO_TESTCASE_2IB (desc, name,321 ); +#define DO_TESTCASE_6x1RR (desc, name) \ + DO_TESTCASE_1RR(desc, name, 123); \ + DO_TESTCASE_1RR(desc, name, 132); \ + DO_TESTCASE_1RR(desc, name, 213); \ + DO_TESTCASE_1RR(desc, name, 231); \ + DO_TESTCASE_1RR(desc, name, 312); \ + DO_TESTCASE_1RR(desc, name, 321); + +#define DO_TESTCASE_6x1RRB (desc, name) \ + DO_TESTCASE_1RRB(desc, name, 123); \ + DO_TESTCASE_1RRB(desc, name, 132); \ + DO_TESTCASE_1RRB(desc, name, 213); \ + DO_TESTCASE_1RRB(desc, name, 231); \ + DO_TESTCASE_1RRB(desc, name, 312); \ + DO_TESTCASE_1RRB(desc, name, 321); +#define DO_TESTCASE_6x6 (desc, name) \ DO_TESTCASE_6I(desc, name, 123); \ DO_TESTCASE_6I(desc, name, 132); \
@@ -2134,6 +2290,11 @@ void locking_selftest(void)pr_cont (" |" );dotest (rlock_chaincache_ABBA1,FAILURE ,LOCKTYPE_RWLOCK ); +DO_TESTCASE_6x1RRB ("rlock W1R2/W2R3/W3R1" ,W1R2_W2R3_W3R1 ); +DO_TESTCASE_6x1RRB ("rlock W1W2/R2R3/W3R1" ,W1W2_R2R3_W3R1 ); +DO_TESTCASE_6x1RR ("rlock W1W2/R2R3/R3W1" ,W1W2_R2R3_R3W1 ); +DO_TESTCASE_6x1RR ("rlock W1R2/R2R3/W3W1" ,W1R2_R2R3_W3W1 ); +printk (" --------------------------------------------------------------------------\n" );/*
Signature · 1 line
2.14.1
Quoted 43 lines · Boqun Feng
Hi Ingo and Peter,
This is V2 for recursive read lock support in lockdep. I fix several bugs in V1 and also add irq inversion detection support for recursive read locks.
V1: https://marc.info/?l=linux-kernel&m=150393341825453
As Peter pointed out:
https://marc.info/?l=linux-kernel&m=150349072023540The lockdep current has a limit support for recursive read locks, the deadlock case as follow could not be detected:
read_lock(A); lock(B); lock(B); write_lock(A);I got some inspiration from Gautham R Shenoy:
https://lwn.net/Articles/332801/, and came up with this series.
The basic idea is:
* Add recursive read locks into the graph
* Classify dependencies into --(RR)-->, --(NR)-->, --(RN)-->,
--(NN)-->, where R stands for recursive read lock, N stands for other locks(i.e. non-recursive read locks and write locks).* Define strong dependency paths as the paths of dependencies
don't have two adjacent dependencies as --(*R)--> and --(R*)-->.* Extend
__bfs()to only traverse on strong dependency paths.* If
__bfs()finds a strong dependency circle, then a deadlock is
reported.
Quoted 7 lines
The whole series is based on current master branch of Linus' tree:
e7d0c41ecc2e ("Merge tag 'devprop-4.14-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm"), and I also put it at:
git://git.kernel.org/pub/scm/linux/kernel/git/boqun/linux.gitarr-rfc-v2
Hmm.. should revert
d82fed752942 ("locking/lockdep/selftests: Fix mixed read-write ABBA tests")
for testing, as it is a work around because of we had limit support for recursive read lock before.
I put a branch with that reverted at:
git://git.kernel.org/pub/scm/linux/kernel/git/boqun/linux.git arr-rfc-v2a
Selftest passed for that branch, now run it for more time.
Regards,
Boqun