Skip to contentSkip to conversation

locking/mutex, drm: Introduce mutex_trylock_recursive()

tip:locking/core Rob Clark 1 participant 1 message Nov 19, 2016 1 message not in the archive

lore
Share & tools
lore

A message that is not in the archive (sent off-list or not yet received): [email protected]

Rob Clark

author Acked-by
#1 lore raw
Quoted 7 lines · tip-bot for Peter Zijlstra
Commit-ID:  0f5225b024d4bffd682aab008c35862e8fdc1865
Gitweb:     http://git.kernel.org/tip/0f5225b024d4bffd682aab008c35862e8fdc1865
Author:     Peter Zijlstra <[email protected]>
AuthorDate: Fri, 7 Oct 2016 17:43:51 +0200
Committer:  Ingo Molnar <[email protected]>
CommitDate: Tue, 15 Nov 2016 14:19:55 +0100
Quoted 8 lines

locking/mutex, drm: Introduce mutex_trylock_recursive()

By popular DRM demand, introduce mutex_trylock_recursive() to fix up the two GEM users.

Without this it is very easy for these drivers to get stuck in low-memory situations and trigger OOM. Work is in progress to remove the need for this in at least i915.

btw, for the drm/msm part,

(and also for the following patch removing the deprecated warnings)

I would also like to rework the locking in drm/msm to be more fine grained and not require this (as i915 plans).. I'm also just one person with a lot else on my plate so I'm not sure I'll get around to that quite as quickly as i915.. (otoh I'll be watching how i915 handles this, since I guess I should be able to follow the same approach)

BR,
-R

Quoted 141 lines
Cc Chris Wilson <[email protected]>
Cc Daniel Vetter <[email protected]>
Cc David Airlie <[email protected]>
Cc Davidlohr Bueso <[email protected]>
Cc Ding Tianhong <[email protected]>
Cc Imre Deak <[email protected]>
Cc Jason Low <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul E. McKenney <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rob Clark <[email protected]>
Cc Terry Rudd <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Tim Chen <[email protected]>
Cc Will Deacon <[email protected]>
---
 drivers/gpu/drm/i915/i915_gem_shrinker.c | 15 ++++++++++++---
 drivers/gpu/drm/msm/msm_gem_shrinker.c   | 16 ++++++++++++----
 include/linux/mutex.h                    | 31 +++++++++++++++++++++++++++++++
 scripts/checkpatch.pl                    |  6 ++++++
 4 files changed, 61 insertions(+), 7 deletions(-)
drivers/gpu/drm/i915/i915_gem_shrinker.c +12 -3
index e9bd2a8..c450076 100644
@@ -227,11 +227,20 @@ unsigned long i915_gem_shrink_all(struct drm_i915_private *dev_priv)
 
 static bool i915_gem_shrinker_lock(struct drm_device *dev, bool *unlock)
 {
-       if (!mutex_trylock(&dev->struct_mutex))
+       switch (mutex_trylock_recursive(&dev->struct_mutex)) {
+       case MUTEX_TRYLOCK_FAILED:
                return false;
 
-       *unlock = true;
-       return true;
+       case MUTEX_TRYLOCK_SUCCESS:
+               *unlock = true;
+               return true;
+
+       case MUTEX_TRYLOCK_RECURSIVE:
+               *unlock = false;
+               return true;
+       }
+
+       BUG();
 }
 
 static unsigned long
drivers/gpu/drm/msm/msm_gem_shrinker.c +12 -4
index 6d2e885..b77bca7 100644
@@ -20,13 +20,21 @@
 
 static bool msm_gem_shrinker_lock(struct drm_device *dev, bool *unlock)
 {
-       if (!mutex_trylock(&dev->struct_mutex))
+       switch (mutex_trylock_recursive(&dev->struct_mutex)) {
+       case MUTEX_TRYLOCK_FAILED:
                return false;
 
-       *unlock = true;
-       return true;
-}
+       case MUTEX_TRYLOCK_SUCCESS:
+               *unlock = true;
+               return true;
+
+       case MUTEX_TRYLOCK_RECURSIVE:
+               *unlock = false;
+               return true;
+       }
 
+       BUG();
+}
 
 static unsigned long
 msm_gem_shrinker_count(struct shrinker *shrinker, struct shrink_control *sc)
include/linux/mutex.h +31 -0
index 4d3bcca..6a902f0 100644
@@ -189,4 +189,35 @@ extern void mutex_unlock(struct mutex *lock);
 
 extern int atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock);
 
+/*
+ * These values are chosen such that FAIL and SUCCESS match the
+ * values of the regular mutex_trylock().
+ */
+enum mutex_trylock_recursive_enum {
+       MUTEX_TRYLOCK_FAILED    = 0,
+       MUTEX_TRYLOCK_SUCCESS   = 1,
+       MUTEX_TRYLOCK_RECURSIVE,
+};
+
+/**
+ * mutex_trylock_recursive - trylock variant that allows recursive locking
+ * @lock: mutex to be locked
+ *
+ * This function should not be used, _ever_. It is purely for hysterical GEM
+ * raisins, and once those are gone this will be removed.
+ *
+ * Returns:
+ *  MUTEX_TRYLOCK_FAILED    - trylock failed,
+ *  MUTEX_TRYLOCK_SUCCESS   - lock acquired,
+ *  MUTEX_TRYLOCK_RECURSIVE - we already owned the lock.
+ */
+static inline __deprecated __must_check enum mutex_trylock_recursive_enum
+mutex_trylock_recursive(struct mutex *lock)
+{
+       if (unlikely(__mutex_owner(lock) == current))
+               return MUTEX_TRYLOCK_RECURSIVE;
+
+       return mutex_trylock(lock);
+}
+
 #endif /* __LINUX_MUTEX_H */
scripts/checkpatch.pl +6 -0
index a8368d1..23f462f6 100755
@@ -6076,6 +6076,12 @@ sub process {
                        }
                }
 
+# check for mutex_trylock_recursive usage
+               if ($line =~ /mutex_trylock_recursive/) {
+                       ERROR("LOCKING",
+                             "recursive locking is bad, do not use this ever.\n" . $herecurr);
+               }
+
 # check for lockdep_set_novalidate_class
                if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
                    $line =~ /__lockdep_no_validate__\s*\)/ ) {