[PATCH v3 2/2] lockdep: Fix merging of hlocks with non-zero references

[Imre Deak]

The sequence

        static DEFINE_WW_CLASS(test_ww_class);

        struct ww_acquire_ctx ww_ctx;
        struct ww_mutex ww_lock_a;
        struct ww_mutex ww_lock_b;
        struct ww_mutex ww_lock_c;
        struct mutex lock_c;

        ww_acquire_init(&ww_ctx, &test_ww_class);

        ww_mutex_init(&ww_lock_a, &test_ww_class);
        ww_mutex_init(&ww_lock_b, &test_ww_class);
        ww_mutex_init(&ww_lock_c, &test_ww_class);

        mutex_init(&lock_c);

        ww_mutex_lock(&ww_lock_a, &ww_ctx);

        mutex_lock(&lock_c);

        ww_mutex_lock(&ww_lock_b, &ww_ctx);
        ww_mutex_lock(&ww_lock_c, &ww_ctx);

        mutex_unlock(&lock_c);  (*)

        ww_mutex_unlock(&ww_lock_c);
        ww_mutex_unlock(&ww_lock_b);
        ww_mutex_unlock(&ww_lock_a);

        ww_acquire_fini(&ww_ctx); (**)

will trigger the following error in __lock_release() when calling
mutex_release() at **:

        DEBUG_LOCKS_WARN_ON(depth <= 0)

The problem is that the hlock merging happening at * updates the
references for test_ww_class incorrectly to 3 whereas it should've
updated it to 4 (representing all the instances for ww_ctx and
ww_lock_[abc]).

Fix this by updating the references during merging correctly taking into
account that we can have non-zero references (both for the hlock that we
merge into another hlock or for the hlock we are merging into).

v2: (Peter)
- Rebase on latest upstream tree.
- Sanitize overflow check and hlock_references() helper.

Cc: Ville Syrjälä <ville.syrj...@linux.intel.com>
Cc: Peter Zijlstra <pet...@infradead.org>
Cc: Ingo Molnar <mi...@redhat.com>
Cc: Will Deacon <will.dea...@arm.com>
Signed-off-by: Imre Deak <imre.d...@intel.com>
---
 kernel/locking/lockdep.c | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/kernel/locking/lockdep.c b/kernel/locking/lockdep.c
index 7a48649ce6bc..1aa6dff3c12c 100644
--- a/kernel/locking/lockdep.c
+++ b/kernel/locking/lockdep.c
@@ -3638,6 +3638,11 @@ print_lock_nested_lock_not_held(struct task_struct *curr,
 
 static int __lock_is_held(const struct lockdep_map *lock, int read);
 
+static inline int hlock_references(struct held_lock *hlock)
+{
+       return hlock->references ? : 1;
+}
+
 /*
  * This gets called for every mutex_lock*()/spin_lock*() operation.
  * We maintain the dependency maps and validate the locking attempt:
@@ -3703,17 +3708,14 @@ static int __lock_acquire(struct lockdep_map *lock, 
unsigned int subclass,
        if (depth) {
                hlock = curr->held_locks + depth - 1;
                if (hlock->class_idx == class_idx && nest_lock) {
-                       if (hlock->references) {
-                               /*
-                                * Check: unsigned int references:12, overflow.
-                                */
-                               if (DEBUG_LOCKS_WARN_ON(hlock->references == (1 
<< 12)-1))
-                                       return 0;
+                       if (!references)
+                               references++;
 
-                               hlock->references++;
-                       } else {
-                               hlock->references = 2;
-                       }
+                       hlock->references = hlock_references(hlock) + 
references;
+
+                       /* Overflow */
+                       if (DEBUG_LOCKS_WARN_ON(hlock->references < references))
+                               return 0;
 
                        return 2;
                }
-- 
2.17.1