* [PATCH] kernel/locking: Add context to ww_mutex_trylock.
@ 2021-09-07 13:20 Maarten Lankhorst
2021-09-07 14:59 ` kernel test robot
2021-09-08 10:14 ` Peter Zijlstra
0 siblings, 2 replies; 20+ messages in thread
From: Maarten Lankhorst @ 2021-09-07 13:20 UTC (permalink / raw)
To: intel-gfx
Cc: dri-devel, Maarten Lankhorst, Peter Zijlstra, Ingo Molnar,
Will Deacon, Waiman Long, Boqun Feng, Liam Girdwood, Mark Brown,
linux-kernel
i915 will soon gain an eviction path that trylock a whole lot of locks
for eviction, getting dmesg failures like below:
BUG: MAX_LOCK_DEPTH too low!
turning off the locking correctness validator.
depth: 48 max: 48!
48 locks held by i915_selftest/5776:
#0: ffff888101a79240 (&dev->mutex){....}-{3:3}, at: __driver_attach+0x88/0x160
#1: ffffc900009778c0 (reservation_ww_class_acquire){+.+.}-{0:0}, at: i915_vma_pin.constprop.63+0x39/0x1b0 [i915]
#2: ffff88800cf74de8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_vma_pin.constprop.63+0x5f/0x1b0 [i915]
#3: ffff88810c7f9e38 (&vm->mutex/1){+.+.}-{3:3}, at: i915_vma_pin_ww+0x1c4/0x9d0 [i915]
#4: ffff88810bad5768 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
#5: ffff88810bad60e8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
...
#46: ffff88811964d768 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
#47: ffff88811964e0e8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
INFO: lockdep is turned off.
Fixing eviction to nest into ww_class_acquire is a high priority,
but it requires a rework of the entire driver, which can only be
done one step at a time.
As an intermediate solution, add an acquire context to ww_mutex_trylock,
which allows us to do proper nesting annotations on the trylocks, making
the above lockdep splat disappear.
This is also useful in regulator_lock_nested, which may avoid dropping
regulator_nesting_mutex in the uncontended path, so use it there.
Signed-off-by: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Will Deacon <will@kernel.org>
Cc: Waiman Long <longman@redhat.com>
Cc: Boqun Feng <boqun.feng@gmail.com>
Cc: Liam Girdwood <lgirdwood@gmail.com>
Cc: Mark Brown <broonie@kernel.org>
Cc: linux-kernel@vger.kernel.org
---
drivers/gpu/drm/drm_modeset_lock.c | 2 +-
drivers/regulator/core.c | 2 +-
include/linux/dma-resv.h | 2 +-
include/linux/ww_mutex.h | 13 +----
kernel/locking/mutex.c | 38 +++++++++++++
kernel/locking/test-ww_mutex.c | 86 ++++++++++++++++++++++--------
lib/locking-selftest.c | 2 +-
7 files changed, 109 insertions(+), 36 deletions(-)
diff --git a/drivers/gpu/drm/drm_modeset_lock.c b/drivers/gpu/drm/drm_modeset_lock.c
index fcfe1a03c4a1..bf8a6e823a15 100644
--- a/drivers/gpu/drm/drm_modeset_lock.c
+++ b/drivers/gpu/drm/drm_modeset_lock.c
@@ -248,7 +248,7 @@ static inline int modeset_lock(struct drm_modeset_lock *lock,
if (ctx->trylock_only) {
lockdep_assert_held(&ctx->ww_ctx);
- if (!ww_mutex_trylock(&lock->mutex))
+ if (!ww_mutex_trylock(&lock->mutex, NULL))
return -EBUSY;
else
return 0;
diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c
index ca6caba8a191..f4d441b1a8bf 100644
--- a/drivers/regulator/core.c
+++ b/drivers/regulator/core.c
@@ -145,7 +145,7 @@ static inline int regulator_lock_nested(struct regulator_dev *rdev,
mutex_lock(®ulator_nesting_mutex);
- if (ww_ctx || !ww_mutex_trylock(&rdev->mutex)) {
+ if (!ww_mutex_trylock(&rdev->mutex, ww_ctx)) {
if (rdev->mutex_owner == current)
rdev->ref_cnt++;
else
diff --git a/include/linux/dma-resv.h b/include/linux/dma-resv.h
index e1ca2080a1ff..39fefb86780b 100644
--- a/include/linux/dma-resv.h
+++ b/include/linux/dma-resv.h
@@ -173,7 +173,7 @@ static inline int dma_resv_lock_slow_interruptible(struct dma_resv *obj,
*/
static inline bool __must_check dma_resv_trylock(struct dma_resv *obj)
{
- return ww_mutex_trylock(&obj->lock);
+ return ww_mutex_trylock(&obj->lock, NULL);
}
/**
diff --git a/include/linux/ww_mutex.h b/include/linux/ww_mutex.h
index b77f39f319ad..0b8f28577c00 100644
--- a/include/linux/ww_mutex.h
+++ b/include/linux/ww_mutex.h
@@ -313,17 +313,8 @@ ww_mutex_lock_slow_interruptible(struct ww_mutex *lock,
extern void ww_mutex_unlock(struct ww_mutex *lock);
-/**
- * ww_mutex_trylock - tries to acquire the w/w mutex without acquire context
- * @lock: mutex to lock
- *
- * Trylocks a mutex without acquire context, so no deadlock detection is
- * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
- */
-static inline int __must_check ww_mutex_trylock(struct ww_mutex *lock)
-{
- return mutex_trylock(&lock->base);
-}
+int __must_check ww_mutex_trylock(struct ww_mutex *lock,
+ struct ww_acquire_ctx *ctx);
/***
* ww_mutex_destroy - mark a w/w mutex unusable
diff --git a/kernel/locking/mutex.c b/kernel/locking/mutex.c
index d2df5e68b503..5d0f5b04b568 100644
--- a/kernel/locking/mutex.c
+++ b/kernel/locking/mutex.c
@@ -1112,6 +1112,44 @@ __ww_mutex_lock(struct mutex *lock, unsigned int state, unsigned int subclass,
return __mutex_lock_common(lock, state, subclass, nest_lock, ip, ww_ctx, true);
}
+/**
+ * ww_mutex_trylock - tries to acquire the w/w mutex with optional acquire context
+ * @lock: mutex to lock
+ * @ctx: optional w/w acquire context
+ *
+ * Trylocks a mutex with the optional acquire context; no deadlock detection is
+ * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
+ *
+ * Unlike ww_mutex_lock, no deadlock handling is performed. However, if a @ctx is
+ * specified, -EALREADY and -EDEADLK handling may happen in calls to ww_mutex_lock.
+ *
+ * A mutex acquired with this function must be released with ww_mutex_unlock.
+ */
+int __sched
+ww_mutex_trylock(struct ww_mutex *ww, struct ww_acquire_ctx *ctx)
+{
+ bool locked;
+
+ if (!ctx)
+ return mutex_trylock(&ww->base);
+
+#ifdef CONFIG_DEBUG_MUTEXES
+ DEBUG_LOCKS_WARN_ON(ww->base.magic != &ww->base);
+#endif
+
+ preempt_disable();
+ locked = __mutex_trylock(&ww->base);
+
+ if (locked) {
+ ww_mutex_set_context_fastpath(ww, ctx);
+ mutex_acquire_nest(&ww->base.dep_map, 0, 1, &ctx->dep_map, _RET_IP_);
+ }
+ preempt_enable();
+
+ return locked;
+}
+EXPORT_SYMBOL(ww_mutex_trylock);
+
#ifdef CONFIG_DEBUG_LOCK_ALLOC
void __sched
mutex_lock_nested(struct mutex *lock, unsigned int subclass)
diff --git a/kernel/locking/test-ww_mutex.c b/kernel/locking/test-ww_mutex.c
index 3e82f449b4ff..d63ac411f367 100644
--- a/kernel/locking/test-ww_mutex.c
+++ b/kernel/locking/test-ww_mutex.c
@@ -16,6 +16,15 @@
static DEFINE_WD_CLASS(ww_class);
struct workqueue_struct *wq;
+#ifdef CONFIG_DEBUG_WW_MUTEX_SLOWPATH
+#define ww_acquire_init_noinject(a, b) do { \
+ ww_acquire_init((a), (b)); \
+ (a)->deadlock_inject_countdown = ~0U; \
+ } while (0)
+#else
+#define ww_acquire_init_noinject(a, b) ww_acquire_init((a), (b))
+#endif
+
struct test_mutex {
struct work_struct work;
struct ww_mutex mutex;
@@ -36,7 +45,7 @@ static void test_mutex_work(struct work_struct *work)
wait_for_completion(&mtx->go);
if (mtx->flags & TEST_MTX_TRY) {
- while (!ww_mutex_trylock(&mtx->mutex))
+ while (!ww_mutex_trylock(&mtx->mutex, NULL))
cond_resched();
} else {
ww_mutex_lock(&mtx->mutex, NULL);
@@ -109,19 +118,38 @@ static int test_mutex(void)
return 0;
}
-static int test_aa(void)
+static int test_aa(bool trylock)
{
struct ww_mutex mutex;
struct ww_acquire_ctx ctx;
int ret;
+ const char *from = trylock ? "trylock" : "lock";
ww_mutex_init(&mutex, &ww_class);
ww_acquire_init(&ctx, &ww_class);
- ww_mutex_lock(&mutex, &ctx);
+ if (!trylock) {
+ ret = ww_mutex_lock(&mutex, &ctx);
+ if (ret) {
+ pr_err("%s: initial lock failed!\n", __func__);
+ goto out;
+ }
+ } else {
+ if (!ww_mutex_trylock(&mutex, &ctx)) {
+ pr_err("%s: initial trylock failed!\n", __func__);
+ goto out;
+ }
+ }
- if (ww_mutex_trylock(&mutex)) {
- pr_err("%s: trylocked itself!\n", __func__);
+ if (ww_mutex_trylock(&mutex, NULL)) {
+ pr_err("%s: trylocked itself without context from %s!\n", __func__, from);
+ ww_mutex_unlock(&mutex);
+ ret = -EINVAL;
+ goto out;
+ }
+
+ if (ww_mutex_trylock(&mutex, &ctx)) {
+ pr_err("%s: trylocked itself with context from %s!\n", __func__, from);
ww_mutex_unlock(&mutex);
ret = -EINVAL;
goto out;
@@ -129,17 +157,17 @@ static int test_aa(void)
ret = ww_mutex_lock(&mutex, &ctx);
if (ret != -EALREADY) {
- pr_err("%s: missed deadlock for recursing, ret=%d\n",
- __func__, ret);
+ pr_err("%s: missed deadlock for recursing, ret=%d from %s\n",
+ __func__, ret, from);
if (!ret)
ww_mutex_unlock(&mutex);
ret = -EINVAL;
goto out;
}
+ ww_mutex_unlock(&mutex);
ret = 0;
out:
- ww_mutex_unlock(&mutex);
ww_acquire_fini(&ctx);
return ret;
}
@@ -150,7 +178,7 @@ struct test_abba {
struct ww_mutex b_mutex;
struct completion a_ready;
struct completion b_ready;
- bool resolve;
+ bool resolve, trylock;
int result;
};
@@ -160,8 +188,13 @@ static void test_abba_work(struct work_struct *work)
struct ww_acquire_ctx ctx;
int err;
- ww_acquire_init(&ctx, &ww_class);
- ww_mutex_lock(&abba->b_mutex, &ctx);
+ ww_acquire_init_noinject(&ctx, &ww_class);
+ if (!abba->trylock)
+ ww_mutex_lock(&abba->b_mutex, &ctx);
+ else
+ WARN_ON(!ww_mutex_trylock(&abba->b_mutex, &ctx));
+
+ WARN_ON(READ_ONCE(abba->b_mutex.ctx) != &ctx);
complete(&abba->b_ready);
wait_for_completion(&abba->a_ready);
@@ -181,7 +214,7 @@ static void test_abba_work(struct work_struct *work)
abba->result = err;
}
-static int test_abba(bool resolve)
+static int test_abba(bool trylock, bool resolve)
{
struct test_abba abba;
struct ww_acquire_ctx ctx;
@@ -192,12 +225,18 @@ static int test_abba(bool resolve)
INIT_WORK_ONSTACK(&abba.work, test_abba_work);
init_completion(&abba.a_ready);
init_completion(&abba.b_ready);
+ abba.trylock = trylock;
abba.resolve = resolve;
schedule_work(&abba.work);
- ww_acquire_init(&ctx, &ww_class);
- ww_mutex_lock(&abba.a_mutex, &ctx);
+ ww_acquire_init_noinject(&ctx, &ww_class);
+ if (!trylock)
+ ww_mutex_lock(&abba.a_mutex, &ctx);
+ else
+ WARN_ON(!ww_mutex_trylock(&abba.a_mutex, &ctx));
+
+ WARN_ON(READ_ONCE(abba.a_mutex.ctx) != &ctx);
complete(&abba.a_ready);
wait_for_completion(&abba.b_ready);
@@ -249,7 +288,7 @@ static void test_cycle_work(struct work_struct *work)
struct ww_acquire_ctx ctx;
int err, erra = 0;
- ww_acquire_init(&ctx, &ww_class);
+ ww_acquire_init_noinject(&ctx, &ww_class);
ww_mutex_lock(&cycle->a_mutex, &ctx);
complete(cycle->a_signal);
@@ -581,7 +620,9 @@ static int stress(int nlocks, int nthreads, unsigned int flags)
static int __init test_ww_mutex_init(void)
{
int ncpus = num_online_cpus();
- int ret;
+ int ret, i;
+
+ printk(KERN_INFO "Beginning ww mutex selftests\n");
wq = alloc_workqueue("test-ww_mutex", WQ_UNBOUND, 0);
if (!wq)
@@ -591,17 +632,19 @@ static int __init test_ww_mutex_init(void)
if (ret)
return ret;
- ret = test_aa();
+ ret = test_aa(false);
if (ret)
return ret;
- ret = test_abba(false);
+ ret = test_aa(true);
if (ret)
return ret;
- ret = test_abba(true);
- if (ret)
- return ret;
+ for (i = 0; i < 4; i++) {
+ ret = test_abba(i & 1, i & 2);
+ if (ret)
+ return ret;
+ }
ret = test_cycle(ncpus);
if (ret)
@@ -619,6 +662,7 @@ static int __init test_ww_mutex_init(void)
if (ret)
return ret;
+ printk(KERN_INFO "All ww mutex selftests passed\n");
return 0;
}
diff --git a/lib/locking-selftest.c b/lib/locking-selftest.c
index 161108e5d2fe..71652e1c397c 100644
--- a/lib/locking-selftest.c
+++ b/lib/locking-selftest.c
@@ -258,7 +258,7 @@ static void init_shared_classes(void)
#define WWAF(x) ww_acquire_fini(x)
#define WWL(x, c) ww_mutex_lock(x, c)
-#define WWT(x) ww_mutex_trylock(x)
+#define WWT(x) ww_mutex_trylock(x, NULL)
#define WWL1(x) ww_mutex_lock(x, NULL)
#define WWU(x) ww_mutex_unlock(x)
--
2.33.0
^ permalink raw reply related [flat|nested] 20+ messages in thread
* Re: [PATCH] kernel/locking: Add context to ww_mutex_trylock.
2021-09-07 13:20 [PATCH] kernel/locking: Add context to ww_mutex_trylock Maarten Lankhorst
@ 2021-09-07 14:59 ` kernel test robot
2021-09-08 10:14 ` Peter Zijlstra
1 sibling, 0 replies; 20+ messages in thread
From: kernel test robot @ 2021-09-07 14:59 UTC (permalink / raw)
To: Maarten Lankhorst, intel-gfx
Cc: llvm, kbuild-all, dri-devel, Maarten Lankhorst, Peter Zijlstra,
Ingo Molnar, Will Deacon, Waiman Long, Boqun Feng, Liam Girdwood,
Mark Brown
[-- Attachment #1: Type: text/plain, Size: 4201 bytes --]
Hi Maarten,
I love your patch! Perhaps something to improve:
[auto build test WARNING on regulator/for-next]
[also build test WARNING on tegra-drm/drm/tegra/for-next v5.14]
[cannot apply to tip/locking/core linus/master next-20210907]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Maarten-Lankhorst/kernel-locking-Add-context-to-ww_mutex_trylock/20210907-212220
base: https://git.kernel.org/pub/scm/linux/kernel/git/broonie/regulator.git for-next
config: mips-buildonly-randconfig-r006-20210906 (attached as .config)
compiler: clang version 14.0.0 (https://github.com/llvm/llvm-project 9c476172b93367d2cb88d7d3f4b1b5b456fa6020)
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# install mips cross compiling tool for clang build
# apt-get install binutils-mips-linux-gnu
# https://github.com/0day-ci/linux/commit/1e66afa09b0aa7d6db3122f0312e10d36f6fa217
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Maarten-Lankhorst/kernel-locking-Add-context-to-ww_mutex_trylock/20210907-212220
git checkout 1e66afa09b0aa7d6db3122f0312e10d36f6fa217
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=mips
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>
All warnings (new ones prefixed by >>):
>> kernel/locking/test-ww_mutex.c:138:7: warning: variable 'ret' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
if (!ww_mutex_trylock(&mutex, &ctx)) {
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
kernel/locking/test-ww_mutex.c:172:9: note: uninitialized use occurs here
return ret;
^~~
kernel/locking/test-ww_mutex.c:138:3: note: remove the 'if' if its condition is always false
if (!ww_mutex_trylock(&mutex, &ctx)) {
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
kernel/locking/test-ww_mutex.c:125:9: note: initialize the variable 'ret' to silence this warning
int ret;
^
= 0
1 warning generated.
vim +138 kernel/locking/test-ww_mutex.c
120
121 static int test_aa(bool trylock)
122 {
123 struct ww_mutex mutex;
124 struct ww_acquire_ctx ctx;
125 int ret;
126 const char *from = trylock ? "trylock" : "lock";
127
128 ww_mutex_init(&mutex, &ww_class);
129 ww_acquire_init(&ctx, &ww_class);
130
131 if (!trylock) {
132 ret = ww_mutex_lock(&mutex, &ctx);
133 if (ret) {
134 pr_err("%s: initial lock failed!\n", __func__);
135 goto out;
136 }
137 } else {
> 138 if (!ww_mutex_trylock(&mutex, &ctx)) {
139 pr_err("%s: initial trylock failed!\n", __func__);
140 goto out;
141 }
142 }
143
144 if (ww_mutex_trylock(&mutex, NULL)) {
145 pr_err("%s: trylocked itself without context from %s!\n", __func__, from);
146 ww_mutex_unlock(&mutex);
147 ret = -EINVAL;
148 goto out;
149 }
150
151 if (ww_mutex_trylock(&mutex, &ctx)) {
152 pr_err("%s: trylocked itself with context from %s!\n", __func__, from);
153 ww_mutex_unlock(&mutex);
154 ret = -EINVAL;
155 goto out;
156 }
157
158 ret = ww_mutex_lock(&mutex, &ctx);
159 if (ret != -EALREADY) {
160 pr_err("%s: missed deadlock for recursing, ret=%d from %s\n",
161 __func__, ret, from);
162 if (!ret)
163 ww_mutex_unlock(&mutex);
164 ret = -EINVAL;
165 goto out;
166 }
167
168 ww_mutex_unlock(&mutex);
169 ret = 0;
170 out:
171 ww_acquire_fini(&ctx);
172 return ret;
173 }
174
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org
[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 30233 bytes --]
^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH] kernel/locking: Add context to ww_mutex_trylock.
2021-09-07 13:20 [PATCH] kernel/locking: Add context to ww_mutex_trylock Maarten Lankhorst
2021-09-07 14:59 ` kernel test robot
@ 2021-09-08 10:14 ` Peter Zijlstra
2021-09-08 18:30 ` Daniel Vetter
2021-09-09 5:38 ` Maarten Lankhorst
1 sibling, 2 replies; 20+ messages in thread
From: Peter Zijlstra @ 2021-09-08 10:14 UTC (permalink / raw)
To: Maarten Lankhorst
Cc: intel-gfx, dri-devel, Ingo Molnar, Will Deacon, Waiman Long,
Boqun Feng, Liam Girdwood, Mark Brown, linux-kernel
On Tue, Sep 07, 2021 at 03:20:44PM +0200, Maarten Lankhorst wrote:
> i915 will soon gain an eviction path that trylock a whole lot of locks
> for eviction, getting dmesg failures like below:
>
> BUG: MAX_LOCK_DEPTH too low!
> turning off the locking correctness validator.
> depth: 48 max: 48!
> 48 locks held by i915_selftest/5776:
> #0: ffff888101a79240 (&dev->mutex){....}-{3:3}, at: __driver_attach+0x88/0x160
> #1: ffffc900009778c0 (reservation_ww_class_acquire){+.+.}-{0:0}, at: i915_vma_pin.constprop.63+0x39/0x1b0 [i915]
> #2: ffff88800cf74de8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_vma_pin.constprop.63+0x5f/0x1b0 [i915]
> #3: ffff88810c7f9e38 (&vm->mutex/1){+.+.}-{3:3}, at: i915_vma_pin_ww+0x1c4/0x9d0 [i915]
> #4: ffff88810bad5768 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
> #5: ffff88810bad60e8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
> ...
> #46: ffff88811964d768 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
> #47: ffff88811964e0e8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
> INFO: lockdep is turned off.
> As an intermediate solution, add an acquire context to ww_mutex_trylock,
> which allows us to do proper nesting annotations on the trylocks, making
> the above lockdep splat disappear.
Fair enough I suppose.
> +/**
> + * ww_mutex_trylock - tries to acquire the w/w mutex with optional acquire context
> + * @lock: mutex to lock
> + * @ctx: optional w/w acquire context
> + *
> + * Trylocks a mutex with the optional acquire context; no deadlock detection is
> + * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
> + *
> + * Unlike ww_mutex_lock, no deadlock handling is performed. However, if a @ctx is
> + * specified, -EALREADY and -EDEADLK handling may happen in calls to ww_mutex_lock.
> + *
> + * A mutex acquired with this function must be released with ww_mutex_unlock.
> + */
> +int __sched
> +ww_mutex_trylock(struct ww_mutex *ww, struct ww_acquire_ctx *ctx)
> +{
> + bool locked;
> +
> + if (!ctx)
> + return mutex_trylock(&ww->base);
> +
> +#ifdef CONFIG_DEBUG_MUTEXES
> + DEBUG_LOCKS_WARN_ON(ww->base.magic != &ww->base);
> +#endif
> +
> + preempt_disable();
> + locked = __mutex_trylock(&ww->base);
> +
> + if (locked) {
> + ww_mutex_set_context_fastpath(ww, ctx);
> + mutex_acquire_nest(&ww->base.dep_map, 0, 1, &ctx->dep_map, _RET_IP_);
> + }
> + preempt_enable();
> +
> + return locked;
> +}
> +EXPORT_SYMBOL(ww_mutex_trylock);
You'll need a similar hunk in ww_rt_mutex.c
^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH] kernel/locking: Add context to ww_mutex_trylock.
2021-09-08 10:14 ` Peter Zijlstra
@ 2021-09-08 18:30 ` Daniel Vetter
2021-09-09 5:38 ` Maarten Lankhorst
1 sibling, 0 replies; 20+ messages in thread
From: Daniel Vetter @ 2021-09-08 18:30 UTC (permalink / raw)
To: Peter Zijlstra
Cc: Maarten Lankhorst, intel-gfx, dri-devel, Ingo Molnar,
Will Deacon, Waiman Long, Boqun Feng, Liam Girdwood, Mark Brown,
linux-kernel
On Wed, Sep 08, 2021 at 12:14:23PM +0200, Peter Zijlstra wrote:
> On Tue, Sep 07, 2021 at 03:20:44PM +0200, Maarten Lankhorst wrote:
> > i915 will soon gain an eviction path that trylock a whole lot of locks
> > for eviction, getting dmesg failures like below:
> >
> > BUG: MAX_LOCK_DEPTH too low!
> > turning off the locking correctness validator.
> > depth: 48 max: 48!
> > 48 locks held by i915_selftest/5776:
> > #0: ffff888101a79240 (&dev->mutex){....}-{3:3}, at: __driver_attach+0x88/0x160
> > #1: ffffc900009778c0 (reservation_ww_class_acquire){+.+.}-{0:0}, at: i915_vma_pin.constprop.63+0x39/0x1b0 [i915]
> > #2: ffff88800cf74de8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_vma_pin.constprop.63+0x5f/0x1b0 [i915]
> > #3: ffff88810c7f9e38 (&vm->mutex/1){+.+.}-{3:3}, at: i915_vma_pin_ww+0x1c4/0x9d0 [i915]
> > #4: ffff88810bad5768 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
> > #5: ffff88810bad60e8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
> > ...
> > #46: ffff88811964d768 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
> > #47: ffff88811964e0e8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
> > INFO: lockdep is turned off.
>
> > As an intermediate solution, add an acquire context to ww_mutex_trylock,
> > which allows us to do proper nesting annotations on the trylocks, making
> > the above lockdep splat disappear.
>
> Fair enough I suppose.
What's maybe missing from the commit message
- we'll probably use this for ttm too eventually
- even when we add full ww_mutex locking we'll still have the trylock
fastpath. This is because we have a lock inversion against list locks in
these eviction paths, and the slow path unroll to drop that list lock is
a bit nasty (and defintely expensive).
iow even long term this here is needed in some form I think.
-Daniel
>
> > +/**
> > + * ww_mutex_trylock - tries to acquire the w/w mutex with optional acquire context
> > + * @lock: mutex to lock
> > + * @ctx: optional w/w acquire context
> > + *
> > + * Trylocks a mutex with the optional acquire context; no deadlock detection is
> > + * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
> > + *
> > + * Unlike ww_mutex_lock, no deadlock handling is performed. However, if a @ctx is
> > + * specified, -EALREADY and -EDEADLK handling may happen in calls to ww_mutex_lock.
> > + *
> > + * A mutex acquired with this function must be released with ww_mutex_unlock.
> > + */
> > +int __sched
> > +ww_mutex_trylock(struct ww_mutex *ww, struct ww_acquire_ctx *ctx)
> > +{
> > + bool locked;
> > +
> > + if (!ctx)
> > + return mutex_trylock(&ww->base);
> > +
> > +#ifdef CONFIG_DEBUG_MUTEXES
> > + DEBUG_LOCKS_WARN_ON(ww->base.magic != &ww->base);
> > +#endif
> > +
> > + preempt_disable();
> > + locked = __mutex_trylock(&ww->base);
> > +
> > + if (locked) {
> > + ww_mutex_set_context_fastpath(ww, ctx);
> > + mutex_acquire_nest(&ww->base.dep_map, 0, 1, &ctx->dep_map, _RET_IP_);
> > + }
> > + preempt_enable();
> > +
> > + return locked;
> > +}
> > +EXPORT_SYMBOL(ww_mutex_trylock);
>
> You'll need a similar hunk in ww_rt_mutex.c
--
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH] kernel/locking: Add context to ww_mutex_trylock.
2021-09-08 10:14 ` Peter Zijlstra
2021-09-08 18:30 ` Daniel Vetter
@ 2021-09-09 5:38 ` Maarten Lankhorst
2021-09-09 8:22 ` Peter Zijlstra
1 sibling, 1 reply; 20+ messages in thread
From: Maarten Lankhorst @ 2021-09-09 5:38 UTC (permalink / raw)
To: Peter Zijlstra
Cc: intel-gfx, dri-devel, Ingo Molnar, Will Deacon, Waiman Long,
Boqun Feng, Liam Girdwood, Mark Brown, linux-kernel
Op 08-09-2021 om 12:14 schreef Peter Zijlstra:
> On Tue, Sep 07, 2021 at 03:20:44PM +0200, Maarten Lankhorst wrote:
>> i915 will soon gain an eviction path that trylock a whole lot of locks
>> for eviction, getting dmesg failures like below:
>>
>> BUG: MAX_LOCK_DEPTH too low!
>> turning off the locking correctness validator.
>> depth: 48 max: 48!
>> 48 locks held by i915_selftest/5776:
>> #0: ffff888101a79240 (&dev->mutex){....}-{3:3}, at: __driver_attach+0x88/0x160
>> #1: ffffc900009778c0 (reservation_ww_class_acquire){+.+.}-{0:0}, at: i915_vma_pin.constprop.63+0x39/0x1b0 [i915]
>> #2: ffff88800cf74de8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_vma_pin.constprop.63+0x5f/0x1b0 [i915]
>> #3: ffff88810c7f9e38 (&vm->mutex/1){+.+.}-{3:3}, at: i915_vma_pin_ww+0x1c4/0x9d0 [i915]
>> #4: ffff88810bad5768 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
>> #5: ffff88810bad60e8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
>> ...
>> #46: ffff88811964d768 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
>> #47: ffff88811964e0e8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
>> INFO: lockdep is turned off.
>> As an intermediate solution, add an acquire context to ww_mutex_trylock,
>> which allows us to do proper nesting annotations on the trylocks, making
>> the above lockdep splat disappear.
> Fair enough I suppose.
>
>> +/**
>> + * ww_mutex_trylock - tries to acquire the w/w mutex with optional acquire context
>> + * @lock: mutex to lock
>> + * @ctx: optional w/w acquire context
>> + *
>> + * Trylocks a mutex with the optional acquire context; no deadlock detection is
>> + * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
>> + *
>> + * Unlike ww_mutex_lock, no deadlock handling is performed. However, if a @ctx is
>> + * specified, -EALREADY and -EDEADLK handling may happen in calls to ww_mutex_lock.
>> + *
>> + * A mutex acquired with this function must be released with ww_mutex_unlock.
>> + */
>> +int __sched
>> +ww_mutex_trylock(struct ww_mutex *ww, struct ww_acquire_ctx *ctx)
>> +{
>> + bool locked;
>> +
>> + if (!ctx)
>> + return mutex_trylock(&ww->base);
>> +
>> +#ifdef CONFIG_DEBUG_MUTEXES
>> + DEBUG_LOCKS_WARN_ON(ww->base.magic != &ww->base);
>> +#endif
>> +
>> + preempt_disable();
>> + locked = __mutex_trylock(&ww->base);
>> +
>> + if (locked) {
>> + ww_mutex_set_context_fastpath(ww, ctx);
>> + mutex_acquire_nest(&ww->base.dep_map, 0, 1, &ctx->dep_map, _RET_IP_);
>> + }
>> + preempt_enable();
>> +
>> + return locked;
>> +}
>> +EXPORT_SYMBOL(ww_mutex_trylock);
> You'll need a similar hunk in ww_rt_mutex.c
What tree has that file?
^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH] kernel/locking: Add context to ww_mutex_trylock.
2021-09-09 5:38 ` Maarten Lankhorst
@ 2021-09-09 8:22 ` Peter Zijlstra
2021-09-09 9:32 ` [PATCH v2] " Maarten Lankhorst
0 siblings, 1 reply; 20+ messages in thread
From: Peter Zijlstra @ 2021-09-09 8:22 UTC (permalink / raw)
To: Maarten Lankhorst
Cc: intel-gfx, dri-devel, Ingo Molnar, Will Deacon, Waiman Long,
Boqun Feng, Liam Girdwood, Mark Brown, linux-kernel
On Thu, Sep 09, 2021 at 07:38:06AM +0200, Maarten Lankhorst wrote:
> > You'll need a similar hunk in ww_rt_mutex.c
>
> What tree has that file?
Linus' tree should have it. Per commit:
f8635d509d80 ("locking/ww_mutex: Implement rtmutex based ww_mutex API functions")
^ permalink raw reply [flat|nested] 20+ messages in thread
* [PATCH v2] kernel/locking: Add context to ww_mutex_trylock.
2021-09-09 8:22 ` Peter Zijlstra
@ 2021-09-09 9:32 ` Maarten Lankhorst
2021-09-10 15:02 ` Peter Zijlstra
2021-09-10 18:06 ` [PATCH v2] kernel/locking: Add context to ww_mutex_trylock Mark Brown
0 siblings, 2 replies; 20+ messages in thread
From: Maarten Lankhorst @ 2021-09-09 9:32 UTC (permalink / raw)
To: Peter Zijlstra
Cc: intel-gfx, dri-devel, Ingo Molnar, Will Deacon, Waiman Long,
Boqun Feng, Liam Girdwood, Mark Brown, linux-kernel,
Daniel Vetter
Op 09-09-2021 om 10:22 schreef Peter Zijlstra:
> On Thu, Sep 09, 2021 at 07:38:06AM +0200, Maarten Lankhorst wrote:
>
>>> You'll need a similar hunk in ww_rt_mutex.c
>> What tree has that file?
> Linus' tree should have it. Per commit:
>
> f8635d509d80 ("locking/ww_mutex: Implement rtmutex based ww_mutex API functions")
Ah yeah, it seems the drm integration tree missed it.
I only compile tested it against PREEMPT_RT, though it seems locking_selftests and fs/inode.c don't build correctly for me.
Improved patch below.
Also hopefully addressed Daniel's concerns.
-------8<------
From d7e867f26b7e2553b0e5b9b5b87a284467b85846 Mon Sep 17 00:00:00 2001
From: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
Date: Fri, 3 Sep 2021 10:59:49 +0200
Subject: [PATCH] kernel/locking: Add context to ww_mutex_trylock, v2.
i915 will soon gain an eviction path that trylock a whole lot of locks
for eviction, getting dmesg failures like below:
BUG: MAX_LOCK_DEPTH too low!
turning off the locking correctness validator.
depth: 48 max: 48!
48 locks held by i915_selftest/5776:
#0: ffff888101a79240 (&dev->mutex){....}-{3:3}, at: __driver_attach+0x88/0x160
#1: ffffc900009778c0 (reservation_ww_class_acquire){+.+.}-{0:0}, at: i915_vma_pin.constprop.63+0x39/0x1b0 [i915]
#2: ffff88800cf74de8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_vma_pin.constprop.63+0x5f/0x1b0 [i915]
#3: ffff88810c7f9e38 (&vm->mutex/1){+.+.}-{3:3}, at: i915_vma_pin_ww+0x1c4/0x9d0 [i915]
#4: ffff88810bad5768 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
#5: ffff88810bad60e8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
...
#46: ffff88811964d768 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
#47: ffff88811964e0e8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
INFO: lockdep is turned off.
Fixing eviction to nest into ww_class_acquire is a high priority,
but it requires a rework of the entire driver, which can only be
done one step at a time.
As an intermediate solution, add an acquire context to ww_mutex_trylock,
which allows us to do proper nesting annotations on the trylocks, making
the above lockdep splat disappear.
This is also useful in regulator_lock_nested, which may avoid dropping
regulator_nesting_mutex in the uncontended path, so use it there.
TTM may be another user for this, where we could lock a buffer in a
fastpath with list locks held, without dropping all locks we hold.
Changes since v1:
- Rebase on top of the ww_rt_mutex rework.
- Add extern to ww_mutex_trylock header definition.
- Expand commit message slightly.
Signed-off-by: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Will Deacon <will@kernel.org>
Cc: Waiman Long <longman@redhat.com>
Cc: Boqun Feng <boqun.feng@gmail.com>
Cc: Liam Girdwood <lgirdwood@gmail.com>
Cc: Mark Brown <broonie@kernel.org>
Cc: linux-kernel@vger.kernel.org
---
drivers/gpu/drm/drm_modeset_lock.c | 2 +-
drivers/regulator/core.c | 2 +-
include/linux/dma-resv.h | 2 +-
include/linux/ww_mutex.h | 15 +-----
kernel/locking/mutex.c | 38 +++++++++++++
kernel/locking/test-ww_mutex.c | 86 ++++++++++++++++++++++--------
kernel/locking/ww_rt_mutex.c | 12 +++++
lib/locking-selftest.c | 2 +-
8 files changed, 121 insertions(+), 38 deletions(-)
diff --git a/drivers/gpu/drm/drm_modeset_lock.c b/drivers/gpu/drm/drm_modeset_lock.c
index fcfe1a03c4a1..bf8a6e823a15 100644
--- a/drivers/gpu/drm/drm_modeset_lock.c
+++ b/drivers/gpu/drm/drm_modeset_lock.c
@@ -248,7 +248,7 @@ static inline int modeset_lock(struct drm_modeset_lock *lock,
if (ctx->trylock_only) {
lockdep_assert_held(&ctx->ww_ctx);
- if (!ww_mutex_trylock(&lock->mutex))
+ if (!ww_mutex_trylock(&lock->mutex, NULL))
return -EBUSY;
else
return 0;
diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c
index ca6caba8a191..f4d441b1a8bf 100644
--- a/drivers/regulator/core.c
+++ b/drivers/regulator/core.c
@@ -145,7 +145,7 @@ static inline int regulator_lock_nested(struct regulator_dev *rdev,
mutex_lock(®ulator_nesting_mutex);
- if (ww_ctx || !ww_mutex_trylock(&rdev->mutex)) {
+ if (!ww_mutex_trylock(&rdev->mutex, ww_ctx)) {
if (rdev->mutex_owner == current)
rdev->ref_cnt++;
else
diff --git a/include/linux/dma-resv.h b/include/linux/dma-resv.h
index 9100dd3dc21f..5de7956818a5 100644
--- a/include/linux/dma-resv.h
+++ b/include/linux/dma-resv.h
@@ -262,7 +262,7 @@ static inline int dma_resv_lock_slow_interruptible(struct dma_resv *obj,
*/
static inline bool __must_check dma_resv_trylock(struct dma_resv *obj)
{
- return ww_mutex_trylock(&obj->lock);
+ return ww_mutex_trylock(&obj->lock, NULL);
}
/**
diff --git a/include/linux/ww_mutex.h b/include/linux/ww_mutex.h
index 29db736af86d..bb763085479a 100644
--- a/include/linux/ww_mutex.h
+++ b/include/linux/ww_mutex.h
@@ -28,12 +28,10 @@
#ifndef CONFIG_PREEMPT_RT
#define WW_MUTEX_BASE mutex
#define ww_mutex_base_init(l,n,k) __mutex_init(l,n,k)
-#define ww_mutex_base_trylock(l) mutex_trylock(l)
#define ww_mutex_base_is_locked(b) mutex_is_locked((b))
#else
#define WW_MUTEX_BASE rt_mutex
#define ww_mutex_base_init(l,n,k) __rt_mutex_init(l,n,k)
-#define ww_mutex_base_trylock(l) rt_mutex_trylock(l)
#define ww_mutex_base_is_locked(b) rt_mutex_base_is_locked(&(b)->rtmutex)
#endif
@@ -339,17 +337,8 @@ ww_mutex_lock_slow_interruptible(struct ww_mutex *lock,
extern void ww_mutex_unlock(struct ww_mutex *lock);
-/**
- * ww_mutex_trylock - tries to acquire the w/w mutex without acquire context
- * @lock: mutex to lock
- *
- * Trylocks a mutex without acquire context, so no deadlock detection is
- * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
- */
-static inline int __must_check ww_mutex_trylock(struct ww_mutex *lock)
-{
- return ww_mutex_base_trylock(&lock->base);
-}
+extern int __must_check ww_mutex_trylock(struct ww_mutex *lock,
+ struct ww_acquire_ctx *ctx);
/***
* ww_mutex_destroy - mark a w/w mutex unusable
diff --git a/kernel/locking/mutex.c b/kernel/locking/mutex.c
index d456579d0952..791c28005eef 100644
--- a/kernel/locking/mutex.c
+++ b/kernel/locking/mutex.c
@@ -736,6 +736,44 @@ __ww_mutex_lock(struct mutex *lock, unsigned int state, unsigned int subclass,
return __mutex_lock_common(lock, state, subclass, NULL, ip, ww_ctx, true);
}
+/**
+ * ww_mutex_trylock - tries to acquire the w/w mutex with optional acquire context
+ * @lock: mutex to lock
+ * @ctx: optional w/w acquire context
+ *
+ * Trylocks a mutex with the optional acquire context; no deadlock detection is
+ * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
+ *
+ * Unlike ww_mutex_lock, no deadlock handling is performed. However, if a @ctx is
+ * specified, -EALREADY and -EDEADLK handling may happen in calls to ww_mutex_lock.
+ *
+ * A mutex acquired with this function must be released with ww_mutex_unlock.
+ */
+int __sched
+ww_mutex_trylock(struct ww_mutex *ww, struct ww_acquire_ctx *ctx)
+{
+ bool locked;
+
+ if (!ctx)
+ return mutex_trylock(&ww->base);
+
+#ifdef CONFIG_DEBUG_MUTEXES
+ DEBUG_LOCKS_WARN_ON(ww->base.magic != &ww->base);
+#endif
+
+ preempt_disable();
+ locked = __mutex_trylock(&ww->base);
+
+ if (locked) {
+ ww_mutex_set_context_fastpath(ww, ctx);
+ mutex_acquire_nest(&ww->base.dep_map, 0, 1, &ctx->dep_map, _RET_IP_);
+ }
+ preempt_enable();
+
+ return locked;
+}
+EXPORT_SYMBOL(ww_mutex_trylock);
+
#ifdef CONFIG_DEBUG_LOCK_ALLOC
void __sched
mutex_lock_nested(struct mutex *lock, unsigned int subclass)
diff --git a/kernel/locking/test-ww_mutex.c b/kernel/locking/test-ww_mutex.c
index 3e82f449b4ff..d63ac411f367 100644
--- a/kernel/locking/test-ww_mutex.c
+++ b/kernel/locking/test-ww_mutex.c
@@ -16,6 +16,15 @@
static DEFINE_WD_CLASS(ww_class);
struct workqueue_struct *wq;
+#ifdef CONFIG_DEBUG_WW_MUTEX_SLOWPATH
+#define ww_acquire_init_noinject(a, b) do { \
+ ww_acquire_init((a), (b)); \
+ (a)->deadlock_inject_countdown = ~0U; \
+ } while (0)
+#else
+#define ww_acquire_init_noinject(a, b) ww_acquire_init((a), (b))
+#endif
+
struct test_mutex {
struct work_struct work;
struct ww_mutex mutex;
@@ -36,7 +45,7 @@ static void test_mutex_work(struct work_struct *work)
wait_for_completion(&mtx->go);
if (mtx->flags & TEST_MTX_TRY) {
- while (!ww_mutex_trylock(&mtx->mutex))
+ while (!ww_mutex_trylock(&mtx->mutex, NULL))
cond_resched();
} else {
ww_mutex_lock(&mtx->mutex, NULL);
@@ -109,19 +118,38 @@ static int test_mutex(void)
return 0;
}
-static int test_aa(void)
+static int test_aa(bool trylock)
{
struct ww_mutex mutex;
struct ww_acquire_ctx ctx;
int ret;
+ const char *from = trylock ? "trylock" : "lock";
ww_mutex_init(&mutex, &ww_class);
ww_acquire_init(&ctx, &ww_class);
- ww_mutex_lock(&mutex, &ctx);
+ if (!trylock) {
+ ret = ww_mutex_lock(&mutex, &ctx);
+ if (ret) {
+ pr_err("%s: initial lock failed!\n", __func__);
+ goto out;
+ }
+ } else {
+ if (!ww_mutex_trylock(&mutex, &ctx)) {
+ pr_err("%s: initial trylock failed!\n", __func__);
+ goto out;
+ }
+ }
- if (ww_mutex_trylock(&mutex)) {
- pr_err("%s: trylocked itself!\n", __func__);
+ if (ww_mutex_trylock(&mutex, NULL)) {
+ pr_err("%s: trylocked itself without context from %s!\n", __func__, from);
+ ww_mutex_unlock(&mutex);
+ ret = -EINVAL;
+ goto out;
+ }
+
+ if (ww_mutex_trylock(&mutex, &ctx)) {
+ pr_err("%s: trylocked itself with context from %s!\n", __func__, from);
ww_mutex_unlock(&mutex);
ret = -EINVAL;
goto out;
@@ -129,17 +157,17 @@ static int test_aa(void)
ret = ww_mutex_lock(&mutex, &ctx);
if (ret != -EALREADY) {
- pr_err("%s: missed deadlock for recursing, ret=%d\n",
- __func__, ret);
+ pr_err("%s: missed deadlock for recursing, ret=%d from %s\n",
+ __func__, ret, from);
if (!ret)
ww_mutex_unlock(&mutex);
ret = -EINVAL;
goto out;
}
+ ww_mutex_unlock(&mutex);
ret = 0;
out:
- ww_mutex_unlock(&mutex);
ww_acquire_fini(&ctx);
return ret;
}
@@ -150,7 +178,7 @@ struct test_abba {
struct ww_mutex b_mutex;
struct completion a_ready;
struct completion b_ready;
- bool resolve;
+ bool resolve, trylock;
int result;
};
@@ -160,8 +188,13 @@ static void test_abba_work(struct work_struct *work)
struct ww_acquire_ctx ctx;
int err;
- ww_acquire_init(&ctx, &ww_class);
- ww_mutex_lock(&abba->b_mutex, &ctx);
+ ww_acquire_init_noinject(&ctx, &ww_class);
+ if (!abba->trylock)
+ ww_mutex_lock(&abba->b_mutex, &ctx);
+ else
+ WARN_ON(!ww_mutex_trylock(&abba->b_mutex, &ctx));
+
+ WARN_ON(READ_ONCE(abba->b_mutex.ctx) != &ctx);
complete(&abba->b_ready);
wait_for_completion(&abba->a_ready);
@@ -181,7 +214,7 @@ static void test_abba_work(struct work_struct *work)
abba->result = err;
}
-static int test_abba(bool resolve)
+static int test_abba(bool trylock, bool resolve)
{
struct test_abba abba;
struct ww_acquire_ctx ctx;
@@ -192,12 +225,18 @@ static int test_abba(bool resolve)
INIT_WORK_ONSTACK(&abba.work, test_abba_work);
init_completion(&abba.a_ready);
init_completion(&abba.b_ready);
+ abba.trylock = trylock;
abba.resolve = resolve;
schedule_work(&abba.work);
- ww_acquire_init(&ctx, &ww_class);
- ww_mutex_lock(&abba.a_mutex, &ctx);
+ ww_acquire_init_noinject(&ctx, &ww_class);
+ if (!trylock)
+ ww_mutex_lock(&abba.a_mutex, &ctx);
+ else
+ WARN_ON(!ww_mutex_trylock(&abba.a_mutex, &ctx));
+
+ WARN_ON(READ_ONCE(abba.a_mutex.ctx) != &ctx);
complete(&abba.a_ready);
wait_for_completion(&abba.b_ready);
@@ -249,7 +288,7 @@ static void test_cycle_work(struct work_struct *work)
struct ww_acquire_ctx ctx;
int err, erra = 0;
- ww_acquire_init(&ctx, &ww_class);
+ ww_acquire_init_noinject(&ctx, &ww_class);
ww_mutex_lock(&cycle->a_mutex, &ctx);
complete(cycle->a_signal);
@@ -581,7 +620,9 @@ static int stress(int nlocks, int nthreads, unsigned int flags)
static int __init test_ww_mutex_init(void)
{
int ncpus = num_online_cpus();
- int ret;
+ int ret, i;
+
+ printk(KERN_INFO "Beginning ww mutex selftests\n");
wq = alloc_workqueue("test-ww_mutex", WQ_UNBOUND, 0);
if (!wq)
@@ -591,17 +632,19 @@ static int __init test_ww_mutex_init(void)
if (ret)
return ret;
- ret = test_aa();
+ ret = test_aa(false);
if (ret)
return ret;
- ret = test_abba(false);
+ ret = test_aa(true);
if (ret)
return ret;
- ret = test_abba(true);
- if (ret)
- return ret;
+ for (i = 0; i < 4; i++) {
+ ret = test_abba(i & 1, i & 2);
+ if (ret)
+ return ret;
+ }
ret = test_cycle(ncpus);
if (ret)
@@ -619,6 +662,7 @@ static int __init test_ww_mutex_init(void)
if (ret)
return ret;
+ printk(KERN_INFO "All ww mutex selftests passed\n");
return 0;
}
diff --git a/kernel/locking/ww_rt_mutex.c b/kernel/locking/ww_rt_mutex.c
index 3f1fff7d2780..c4cb863edb4c 100644
--- a/kernel/locking/ww_rt_mutex.c
+++ b/kernel/locking/ww_rt_mutex.c
@@ -50,6 +50,18 @@ __ww_rt_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ww_ctx,
return ret;
}
+int __sched
+ww_mutex_trylock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
+{
+ int locked = rt_mutex_trylock(&lock->base);
+
+ if (locked && ctx)
+ ww_mutex_set_context_fastpath(lock, ctx);
+
+ return locked;
+}
+EXPORT_SYMBOL(ww_mutex_trylock);
+
int __sched
ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
{
diff --git a/lib/locking-selftest.c b/lib/locking-selftest.c
index 161108e5d2fe..71652e1c397c 100644
--- a/lib/locking-selftest.c
+++ b/lib/locking-selftest.c
@@ -258,7 +258,7 @@ static void init_shared_classes(void)
#define WWAF(x) ww_acquire_fini(x)
#define WWL(x, c) ww_mutex_lock(x, c)
-#define WWT(x) ww_mutex_trylock(x)
+#define WWT(x) ww_mutex_trylock(x, NULL)
#define WWL1(x) ww_mutex_lock(x, NULL)
#define WWU(x) ww_mutex_unlock(x)
--
2.33.0
^ permalink raw reply related [flat|nested] 20+ messages in thread
* Re: [PATCH v2] kernel/locking: Add context to ww_mutex_trylock.
2021-09-09 9:32 ` [PATCH v2] " Maarten Lankhorst
@ 2021-09-10 15:02 ` Peter Zijlstra
2021-09-10 17:27 ` Peter Zijlstra
2021-09-13 8:42 ` Maarten Lankhorst
2021-09-10 18:06 ` [PATCH v2] kernel/locking: Add context to ww_mutex_trylock Mark Brown
1 sibling, 2 replies; 20+ messages in thread
From: Peter Zijlstra @ 2021-09-10 15:02 UTC (permalink / raw)
To: Maarten Lankhorst
Cc: intel-gfx, dri-devel, Ingo Molnar, Will Deacon, Waiman Long,
Boqun Feng, Liam Girdwood, Mark Brown, linux-kernel,
Daniel Vetter
On Thu, Sep 09, 2021 at 11:32:18AM +0200, Maarten Lankhorst wrote:
> diff --git a/kernel/locking/mutex.c b/kernel/locking/mutex.c
> index d456579d0952..791c28005eef 100644
> --- a/kernel/locking/mutex.c
> +++ b/kernel/locking/mutex.c
> @@ -736,6 +736,44 @@ __ww_mutex_lock(struct mutex *lock, unsigned int state, unsigned int subclass,
> return __mutex_lock_common(lock, state, subclass, NULL, ip, ww_ctx, true);
> }
>
> +/**
> + * ww_mutex_trylock - tries to acquire the w/w mutex with optional acquire context
> + * @lock: mutex to lock
> + * @ctx: optional w/w acquire context
> + *
> + * Trylocks a mutex with the optional acquire context; no deadlock detection is
> + * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
> + *
> + * Unlike ww_mutex_lock, no deadlock handling is performed. However, if a @ctx is
> + * specified, -EALREADY and -EDEADLK handling may happen in calls to ww_mutex_lock.
> + *
> + * A mutex acquired with this function must be released with ww_mutex_unlock.
> + */
> +int __sched
> +ww_mutex_trylock(struct ww_mutex *ww, struct ww_acquire_ctx *ctx)
> +{
> + bool locked;
> +
> + if (!ctx)
> + return mutex_trylock(&ww->base);
> +
> +#ifdef CONFIG_DEBUG_MUTEXES
> + DEBUG_LOCKS_WARN_ON(ww->base.magic != &ww->base);
> +#endif
> +
> + preempt_disable();
> + locked = __mutex_trylock(&ww->base);
> +
> + if (locked) {
> + ww_mutex_set_context_fastpath(ww, ctx);
> + mutex_acquire_nest(&ww->base.dep_map, 0, 1, &ctx->dep_map, _RET_IP_);
> + }
> + preempt_enable();
> +
> + return locked;
> +}
> +EXPORT_SYMBOL(ww_mutex_trylock);
> +
> #ifdef CONFIG_DEBUG_LOCK_ALLOC
> void __sched
> mutex_lock_nested(struct mutex *lock, unsigned int subclass)
> diff --git a/kernel/locking/ww_rt_mutex.c b/kernel/locking/ww_rt_mutex.c
> index 3f1fff7d2780..c4cb863edb4c 100644
> --- a/kernel/locking/ww_rt_mutex.c
> +++ b/kernel/locking/ww_rt_mutex.c
> @@ -50,6 +50,18 @@ __ww_rt_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ww_ctx,
> return ret;
> }
>
> +int __sched
> +ww_mutex_trylock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
> +{
> + int locked = rt_mutex_trylock(&lock->base);
> +
> + if (locked && ctx)
> + ww_mutex_set_context_fastpath(lock, ctx);
> +
> + return locked;
> +}
> +EXPORT_SYMBOL(ww_mutex_trylock);
> +
> int __sched
> ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
> {
That doesn't look right, how's this for you?
---
--- a/kernel/locking/mutex.c
+++ b/kernel/locking/mutex.c
@@ -94,6 +94,9 @@ static inline unsigned long __owner_flag
return owner & MUTEX_FLAGS;
}
+/*
+ * Returns: __mutex_owner(lock) on failure or NULL on success.
+ */
static inline struct task_struct *__mutex_trylock_common(struct mutex *lock, bool handoff)
{
unsigned long owner, curr = (unsigned long)current;
@@ -736,6 +739,47 @@ __ww_mutex_lock(struct mutex *lock, unsi
return __mutex_lock_common(lock, state, subclass, NULL, ip, ww_ctx, true);
}
+/**
+ * ww_mutex_trylock - tries to acquire the w/w mutex with optional acquire context
+ * @ww: mutex to lock
+ * @ww_ctx: optional w/w acquire context
+ *
+ * Trylocks a mutex with the optional acquire context; no deadlock detection is
+ * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
+ *
+ * Unlike ww_mutex_lock, no deadlock handling is performed. However, if a @ctx is
+ * specified, -EALREADY handling may happen in calls to ww_mutex_trylock.
+ *
+ * A mutex acquired with this function must be released with ww_mutex_unlock.
+ */
+int ww_mutex_trylock(struct ww_mutex *ww, struct ww_acquire_ctx *ww_ctx)
+{
+ if (!ww_ctx)
+ return mutex_trylock(&ww->base);
+
+ MUTEX_WARN_ON(ww->base.magic != &ww->base);
+
+ if (unlikely(ww_ctx == READ_ONCE(ww->ctx)))
+ return -EALREADY;
+
+ /*
+ * Reset the wounded flag after a kill. No other process can
+ * race and wound us here, since they can't have a valid owner
+ * pointer if we don't have any locks held.
+ */
+ if (ww_ctx->acquired == 0)
+ ww_ctx->wounded = 0;
+
+ if (__mutex_trylock(&ww->base)) {
+ ww_mutex_set_context_fastpath(ww, ww_ctx);
+ mutex_acquire_nest(&ww->base.dep_map, 0, 1, &ww_ctx->dep_map, _RET_IP_);
+ return 1;
+ }
+
+ return 0;
+}
+EXPORT_SYMBOL(ww_mutex_trylock);
+
#ifdef CONFIG_DEBUG_LOCK_ALLOC
void __sched
mutex_lock_nested(struct mutex *lock, unsigned int subclass)
--- a/kernel/locking/ww_rt_mutex.c
+++ b/kernel/locking/ww_rt_mutex.c
@@ -9,6 +9,34 @@
#define WW_RT
#include "rtmutex.c"
+int ww_mutex_trylock(struct ww_mutex *lock, struct ww_acquire_ctx *ww_ctx)
+{
+ struct rt_mutex *rtm = &lock->base;
+
+ if (!ww_ctx)
+ return rt_mutex_trylock(rtm);
+
+ if (unlikely(ww_ctx == READ_ONCE(lock->ctx)))
+ return -EALREADY;
+
+ /*
+ * Reset the wounded flag after a kill. No other process can
+ * race and wound us here, since they can't have a valid owner
+ * pointer if we don't have any locks held.
+ */
+ if (ww_ctx->acquired == 0)
+ ww_ctx->wounded = 0;
+
+ if (__rt_mutex_trylock(&rtm->rtmutex)) {
+ ww_mutex_set_context_fastpath(lock, ww_ctx);
+ mutex_acquire_nest(&rtm->dep_map, 0, 1, ww_ctx->dep_map, _RET_IP_);
+ return 1;
+ }
+
+ return 0;
+}
+EXPORT_SYMBOL(ww_mutex_trylock);
+
static int __sched
__ww_rt_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ww_ctx,
unsigned int state, unsigned long ip)
^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v2] kernel/locking: Add context to ww_mutex_trylock.
2021-09-10 15:02 ` Peter Zijlstra
@ 2021-09-10 17:27 ` Peter Zijlstra
2021-09-13 8:42 ` Maarten Lankhorst
1 sibling, 0 replies; 20+ messages in thread
From: Peter Zijlstra @ 2021-09-10 17:27 UTC (permalink / raw)
To: Maarten Lankhorst
Cc: intel-gfx, dri-devel, Ingo Molnar, Will Deacon, Waiman Long,
Boqun Feng, Liam Girdwood, Mark Brown, linux-kernel,
Daniel Vetter
On Fri, Sep 10, 2021 at 05:02:54PM +0200, Peter Zijlstra wrote:
> That doesn't look right, how's this for you?
Full patch for the robots here:
https://git.kernel.org/pub/scm/linux/kernel/git/peterz/queue.git/commit/?h=locking/core&id=826e7b8826f0af185bb93249600533c33fd69a95
^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v2] kernel/locking: Add context to ww_mutex_trylock.
2021-09-09 9:32 ` [PATCH v2] " Maarten Lankhorst
2021-09-10 15:02 ` Peter Zijlstra
@ 2021-09-10 18:06 ` Mark Brown
1 sibling, 0 replies; 20+ messages in thread
From: Mark Brown @ 2021-09-10 18:06 UTC (permalink / raw)
To: Maarten Lankhorst
Cc: Peter Zijlstra, intel-gfx, dri-devel, Ingo Molnar, Will Deacon,
Waiman Long, Boqun Feng, Liam Girdwood, linux-kernel,
Daniel Vetter
[-- Attachment #1: Type: text/plain, Size: 252 bytes --]
On Thu, Sep 09, 2021 at 11:32:18AM +0200, Maarten Lankhorst wrote:
> This is also useful in regulator_lock_nested, which may avoid dropping
> regulator_nesting_mutex in the uncontended path, so use it there.
Acked-by: Mark Brown <broonie@kernel.org>
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v2] kernel/locking: Add context to ww_mutex_trylock.
2021-09-10 15:02 ` Peter Zijlstra
2021-09-10 17:27 ` Peter Zijlstra
@ 2021-09-13 8:42 ` Maarten Lankhorst
2021-09-14 6:50 ` Peter Zijlstra
1 sibling, 1 reply; 20+ messages in thread
From: Maarten Lankhorst @ 2021-09-13 8:42 UTC (permalink / raw)
To: Peter Zijlstra
Cc: intel-gfx, dri-devel, Ingo Molnar, Will Deacon, Waiman Long,
Boqun Feng, Liam Girdwood, Mark Brown, linux-kernel,
Daniel Vetter
Op 10-09-2021 om 17:02 schreef Peter Zijlstra:
> On Thu, Sep 09, 2021 at 11:32:18AM +0200, Maarten Lankhorst wrote:
>> diff --git a/kernel/locking/mutex.c b/kernel/locking/mutex.c
>> index d456579d0952..791c28005eef 100644
>> --- a/kernel/locking/mutex.c
>> +++ b/kernel/locking/mutex.c
>> @@ -736,6 +736,44 @@ __ww_mutex_lock(struct mutex *lock, unsigned int state, unsigned int subclass,
>> return __mutex_lock_common(lock, state, subclass, NULL, ip, ww_ctx, true);
>> }
>>
>> +/**
>> + * ww_mutex_trylock - tries to acquire the w/w mutex with optional acquire context
>> + * @lock: mutex to lock
>> + * @ctx: optional w/w acquire context
>> + *
>> + * Trylocks a mutex with the optional acquire context; no deadlock detection is
>> + * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
>> + *
>> + * Unlike ww_mutex_lock, no deadlock handling is performed. However, if a @ctx is
>> + * specified, -EALREADY and -EDEADLK handling may happen in calls to ww_mutex_lock.
>> + *
>> + * A mutex acquired with this function must be released with ww_mutex_unlock.
>> + */
>> +int __sched
>> +ww_mutex_trylock(struct ww_mutex *ww, struct ww_acquire_ctx *ctx)
>> +{
>> + bool locked;
>> +
>> + if (!ctx)
>> + return mutex_trylock(&ww->base);
>> +
>> +#ifdef CONFIG_DEBUG_MUTEXES
>> + DEBUG_LOCKS_WARN_ON(ww->base.magic != &ww->base);
>> +#endif
>> +
>> + preempt_disable();
>> + locked = __mutex_trylock(&ww->base);
>> +
>> + if (locked) {
>> + ww_mutex_set_context_fastpath(ww, ctx);
>> + mutex_acquire_nest(&ww->base.dep_map, 0, 1, &ctx->dep_map, _RET_IP_);
>> + }
>> + preempt_enable();
>> +
>> + return locked;
>> +}
>> +EXPORT_SYMBOL(ww_mutex_trylock);
>> +
>> #ifdef CONFIG_DEBUG_LOCK_ALLOC
>> void __sched
>> mutex_lock_nested(struct mutex *lock, unsigned int subclass)
>> diff --git a/kernel/locking/ww_rt_mutex.c b/kernel/locking/ww_rt_mutex.c
>> index 3f1fff7d2780..c4cb863edb4c 100644
>> --- a/kernel/locking/ww_rt_mutex.c
>> +++ b/kernel/locking/ww_rt_mutex.c
>> @@ -50,6 +50,18 @@ __ww_rt_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ww_ctx,
>> return ret;
>> }
>>
>> +int __sched
>> +ww_mutex_trylock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
>> +{
>> + int locked = rt_mutex_trylock(&lock->base);
>> +
>> + if (locked && ctx)
>> + ww_mutex_set_context_fastpath(lock, ctx);
>> +
>> + return locked;
>> +}
>> +EXPORT_SYMBOL(ww_mutex_trylock);
>> +
>> int __sched
>> ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
>> {
> That doesn't look right, how's this for you?
>
> ---
> --- a/kernel/locking/mutex.c
> +++ b/kernel/locking/mutex.c
> @@ -94,6 +94,9 @@ static inline unsigned long __owner_flag
> return owner & MUTEX_FLAGS;
> }
>
> +/*
> + * Returns: __mutex_owner(lock) on failure or NULL on success.
> + */
> static inline struct task_struct *__mutex_trylock_common(struct mutex *lock, bool handoff)
> {
> unsigned long owner, curr = (unsigned long)current;
> @@ -736,6 +739,47 @@ __ww_mutex_lock(struct mutex *lock, unsi
> return __mutex_lock_common(lock, state, subclass, NULL, ip, ww_ctx, true);
> }
>
> +/**
> + * ww_mutex_trylock - tries to acquire the w/w mutex with optional acquire context
> + * @ww: mutex to lock
> + * @ww_ctx: optional w/w acquire context
> + *
> + * Trylocks a mutex with the optional acquire context; no deadlock detection is
> + * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
> + *
> + * Unlike ww_mutex_lock, no deadlock handling is performed. However, if a @ctx is
> + * specified, -EALREADY handling may happen in calls to ww_mutex_trylock.
> + *
> + * A mutex acquired with this function must be released with ww_mutex_unlock.
> + */
> +int ww_mutex_trylock(struct ww_mutex *ww, struct ww_acquire_ctx *ww_ctx)
> +{
> + if (!ww_ctx)
> + return mutex_trylock(&ww->base);
> +
> + MUTEX_WARN_ON(ww->base.magic != &ww->base);
> +
> + if (unlikely(ww_ctx == READ_ONCE(ww->ctx)))
> + return -EALREADY;
I'm not 100% sure this is a good idea, because it would make the trylock weird.
For i915 I checked manually, because I didn't want to change the function signature. This is probably the other extreme.
"if (ww_mutex_trylock())" would look correct, but actually be wrong and lead to double unlock without adjustments.
Maybe we could make a ww_mutex_trylock_ctx_err, which would return -EALREADY or -EBUSY on failure, and 0 on success?
We could keep ww_mutex_trylock without ctx, probably just #define as (!ww_mutex_trylock_ctx_err(lock, NULL))
> + /*
> + * Reset the wounded flag after a kill. No other process can
> + * race and wound us here, since they can't have a valid owner
> + * pointer if we don't have any locks held.
> + */
> + if (ww_ctx->acquired == 0)
> + ww_ctx->wounded = 0;
Yeah I guess this needs fixing too. Not completely sure since trylock wouldn't do the whole
ww dance, but since it's our first lock, probably best to do so regardless so other users don't trip over it.
> +
> + if (__mutex_trylock(&ww->base)) {
> + ww_mutex_set_context_fastpath(ww, ww_ctx);
> + mutex_acquire_nest(&ww->base.dep_map, 0, 1, &ww_ctx->dep_map, _RET_IP_);
> + return 1;
> + }
> +
> + return 0;
> +}
> +EXPORT_SYMBOL(ww_mutex_trylock);
> +
> #ifdef CONFIG_DEBUG_LOCK_ALLOC
> void __sched
> mutex_lock_nested(struct mutex *lock, unsigned int subclass)
> --- a/kernel/locking/ww_rt_mutex.c
> +++ b/kernel/locking/ww_rt_mutex.c
> @@ -9,6 +9,34 @@
> #define WW_RT
> #include "rtmutex.c"
>
> +int ww_mutex_trylock(struct ww_mutex *lock, struct ww_acquire_ctx *ww_ctx)
> +{
> + struct rt_mutex *rtm = &lock->base;
> +
> + if (!ww_ctx)
> + return rt_mutex_trylock(rtm);
> +
> + if (unlikely(ww_ctx == READ_ONCE(lock->ctx)))
> + return -EALREADY;
> +
> + /*
> + * Reset the wounded flag after a kill. No other process can
> + * race and wound us here, since they can't have a valid owner
> + * pointer if we don't have any locks held.
> + */
> + if (ww_ctx->acquired == 0)
> + ww_ctx->wounded = 0;
> +
> + if (__rt_mutex_trylock(&rtm->rtmutex)) {
> + ww_mutex_set_context_fastpath(lock, ww_ctx);
> + mutex_acquire_nest(&rtm->dep_map, 0, 1, ww_ctx->dep_map, _RET_IP_);
> + return 1;
> + }
> +
> + return 0;
> +}
> +EXPORT_SYMBOL(ww_mutex_trylock);
> +
> static int __sched
> __ww_rt_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ww_ctx,
> unsigned int state, unsigned long ip)
^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v2] kernel/locking: Add context to ww_mutex_trylock.
2021-09-13 8:42 ` Maarten Lankhorst
@ 2021-09-14 6:50 ` Peter Zijlstra
2021-09-14 12:43 ` Maarten Lankhorst
2021-11-04 12:27 ` [PATCH] kernel/locking: Use a pointer in ww_mutex_trylock() Sebastian Andrzej Siewior
0 siblings, 2 replies; 20+ messages in thread
From: Peter Zijlstra @ 2021-09-14 6:50 UTC (permalink / raw)
To: Maarten Lankhorst
Cc: intel-gfx, dri-devel, Ingo Molnar, Will Deacon, Waiman Long,
Boqun Feng, Liam Girdwood, Mark Brown, linux-kernel,
Daniel Vetter
On Mon, Sep 13, 2021 at 10:42:36AM +0200, Maarten Lankhorst wrote:
> > +/**
> > + * ww_mutex_trylock - tries to acquire the w/w mutex with optional acquire context
> > + * @ww: mutex to lock
> > + * @ww_ctx: optional w/w acquire context
> > + *
> > + * Trylocks a mutex with the optional acquire context; no deadlock detection is
> > + * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
> > + *
> > + * Unlike ww_mutex_lock, no deadlock handling is performed. However, if a @ctx is
> > + * specified, -EALREADY handling may happen in calls to ww_mutex_trylock.
> > + *
> > + * A mutex acquired with this function must be released with ww_mutex_unlock.
> > + */
> > +int ww_mutex_trylock(struct ww_mutex *ww, struct ww_acquire_ctx *ww_ctx)
> > +{
> > + if (!ww_ctx)
> > + return mutex_trylock(&ww->base);
> > +
> > + MUTEX_WARN_ON(ww->base.magic != &ww->base);
> > +
> > + if (unlikely(ww_ctx == READ_ONCE(ww->ctx)))
> > + return -EALREADY;
>
> I'm not 100% sure this is a good idea, because it would make the
> trylock weird. For i915 I checked manually, because I didn't want to
> change the function signature. This is probably the other extreme.
>
> "if (ww_mutex_trylock())" would look correct, but actually be wrong
> and lead to double unlock without adjustments. Maybe we could make a
> ww_mutex_trylock_ctx_err, which would return -EALREADY or -EBUSY on
> failure, and 0 on success? We could keep ww_mutex_trylock without
> ctx, probably just #define as (!ww_mutex_trylock_ctx_err(lock, NULL))
Urgh, yeah. Also, I suppose that if we already own it, we'll just fail
the trylock anyway. Let me take this out.
> > + /*
> > + * Reset the wounded flag after a kill. No other process can
> > + * race and wound us here, since they can't have a valid owner
> > + * pointer if we don't have any locks held.
> > + */
> > + if (ww_ctx->acquired == 0)
> > + ww_ctx->wounded = 0;
>
> Yeah I guess this needs fixing too. Not completely sure since trylock
> wouldn't do the whole ww dance, but since it's our first lock,
> probably best to do so regardless so other users don't trip over it.
This is actually critical, because if this trylock is the first lock
acquisition for the context, there won't be any other opportunity to
reset this value.
> > +
> > + if (__mutex_trylock(&ww->base)) {
> > + ww_mutex_set_context_fastpath(ww, ww_ctx);
> > + mutex_acquire_nest(&ww->base.dep_map, 0, 1, &ww_ctx->dep_map, _RET_IP_);
> > + return 1;
> > + }
> > +
> > + return 0;
> > +}
> > +EXPORT_SYMBOL(ww_mutex_trylock);
Updated version below...
---
Subject: kernel/locking: Add context to ww_mutex_trylock()
From: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
Date: Thu, 9 Sep 2021 11:32:18 +0200
From: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
i915 will soon gain an eviction path that trylock a whole lot of locks
for eviction, getting dmesg failures like below:
BUG: MAX_LOCK_DEPTH too low!
turning off the locking correctness validator.
depth: 48 max: 48!
48 locks held by i915_selftest/5776:
#0: ffff888101a79240 (&dev->mutex){....}-{3:3}, at: __driver_attach+0x88/0x160
#1: ffffc900009778c0 (reservation_ww_class_acquire){+.+.}-{0:0}, at: i915_vma_pin.constprop.63+0x39/0x1b0 [i915]
#2: ffff88800cf74de8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_vma_pin.constprop.63+0x5f/0x1b0 [i915]
#3: ffff88810c7f9e38 (&vm->mutex/1){+.+.}-{3:3}, at: i915_vma_pin_ww+0x1c4/0x9d0 [i915]
#4: ffff88810bad5768 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
#5: ffff88810bad60e8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
...
#46: ffff88811964d768 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
#47: ffff88811964e0e8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
INFO: lockdep is turned off.
Fixing eviction to nest into ww_class_acquire is a high priority, but
it requires a rework of the entire driver, which can only be done one
step at a time.
As an intermediate solution, add an acquire context to
ww_mutex_trylock, which allows us to do proper nesting annotations on
the trylocks, making the above lockdep splat disappear.
This is also useful in regulator_lock_nested, which may avoid dropping
regulator_nesting_mutex in the uncontended path, so use it there.
TTM may be another user for this, where we could lock a buffer in a
fastpath with list locks held, without dropping all locks we hold.
[peterz: rework actual ww_mutex_trylock() implementations]
Signed-off-by: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
---
drivers/gpu/drm/drm_modeset_lock.c | 2
drivers/regulator/core.c | 2
include/linux/dma-resv.h | 2
include/linux/ww_mutex.h | 15 ------
kernel/locking/mutex.c | 41 +++++++++++++++++
kernel/locking/test-ww_mutex.c | 86 +++++++++++++++++++++++++++----------
kernel/locking/ww_rt_mutex.c | 25 ++++++++++
lib/locking-selftest.c | 2
8 files changed, 137 insertions(+), 38 deletions(-)
--- a/drivers/gpu/drm/drm_modeset_lock.c
+++ b/drivers/gpu/drm/drm_modeset_lock.c
@@ -248,7 +248,7 @@ static inline int modeset_lock(struct dr
if (ctx->trylock_only) {
lockdep_assert_held(&ctx->ww_ctx);
- if (!ww_mutex_trylock(&lock->mutex))
+ if (!ww_mutex_trylock(&lock->mutex, NULL))
return -EBUSY;
else
return 0;
--- a/drivers/regulator/core.c
+++ b/drivers/regulator/core.c
@@ -145,7 +145,7 @@ static inline int regulator_lock_nested(
mutex_lock(®ulator_nesting_mutex);
- if (ww_ctx || !ww_mutex_trylock(&rdev->mutex)) {
+ if (!ww_mutex_trylock(&rdev->mutex, ww_ctx)) {
if (rdev->mutex_owner == current)
rdev->ref_cnt++;
else
--- a/include/linux/dma-resv.h
+++ b/include/linux/dma-resv.h
@@ -173,7 +173,7 @@ static inline int dma_resv_lock_slow_int
*/
static inline bool __must_check dma_resv_trylock(struct dma_resv *obj)
{
- return ww_mutex_trylock(&obj->lock);
+ return ww_mutex_trylock(&obj->lock, NULL);
}
/**
--- a/include/linux/ww_mutex.h
+++ b/include/linux/ww_mutex.h
@@ -28,12 +28,10 @@
#ifndef CONFIG_PREEMPT_RT
#define WW_MUTEX_BASE mutex
#define ww_mutex_base_init(l,n,k) __mutex_init(l,n,k)
-#define ww_mutex_base_trylock(l) mutex_trylock(l)
#define ww_mutex_base_is_locked(b) mutex_is_locked((b))
#else
#define WW_MUTEX_BASE rt_mutex
#define ww_mutex_base_init(l,n,k) __rt_mutex_init(l,n,k)
-#define ww_mutex_base_trylock(l) rt_mutex_trylock(l)
#define ww_mutex_base_is_locked(b) rt_mutex_base_is_locked(&(b)->rtmutex)
#endif
@@ -339,17 +337,8 @@ ww_mutex_lock_slow_interruptible(struct
extern void ww_mutex_unlock(struct ww_mutex *lock);
-/**
- * ww_mutex_trylock - tries to acquire the w/w mutex without acquire context
- * @lock: mutex to lock
- *
- * Trylocks a mutex without acquire context, so no deadlock detection is
- * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
- */
-static inline int __must_check ww_mutex_trylock(struct ww_mutex *lock)
-{
- return ww_mutex_base_trylock(&lock->base);
-}
+extern int __must_check ww_mutex_trylock(struct ww_mutex *lock,
+ struct ww_acquire_ctx *ctx);
/***
* ww_mutex_destroy - mark a w/w mutex unusable
--- a/kernel/locking/mutex.c
+++ b/kernel/locking/mutex.c
@@ -94,6 +94,9 @@ static inline unsigned long __owner_flag
return owner & MUTEX_FLAGS;
}
+/*
+ * Returns: __mutex_owner(lock) on failure or NULL on success.
+ */
static inline struct task_struct *__mutex_trylock_common(struct mutex *lock, bool handoff)
{
unsigned long owner, curr = (unsigned long)current;
@@ -736,6 +739,44 @@ __ww_mutex_lock(struct mutex *lock, unsi
return __mutex_lock_common(lock, state, subclass, NULL, ip, ww_ctx, true);
}
+/**
+ * ww_mutex_trylock - tries to acquire the w/w mutex with optional acquire context
+ * @ww: mutex to lock
+ * @ww_ctx: optional w/w acquire context
+ *
+ * Trylocks a mutex with the optional acquire context; no deadlock detection is
+ * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
+ *
+ * Unlike ww_mutex_lock, no deadlock handling is performed. However, if a @ctx is
+ * specified, -EALREADY handling may happen in calls to ww_mutex_trylock.
+ *
+ * A mutex acquired with this function must be released with ww_mutex_unlock.
+ */
+int ww_mutex_trylock(struct ww_mutex *ww, struct ww_acquire_ctx *ww_ctx)
+{
+ if (!ww_ctx)
+ return mutex_trylock(&ww->base);
+
+ MUTEX_WARN_ON(ww->base.magic != &ww->base);
+
+ /*
+ * Reset the wounded flag after a kill. No other process can
+ * race and wound us here, since they can't have a valid owner
+ * pointer if we don't have any locks held.
+ */
+ if (ww_ctx->acquired == 0)
+ ww_ctx->wounded = 0;
+
+ if (__mutex_trylock(&ww->base)) {
+ ww_mutex_set_context_fastpath(ww, ww_ctx);
+ mutex_acquire_nest(&ww->base.dep_map, 0, 1, &ww_ctx->dep_map, _RET_IP_);
+ return 1;
+ }
+
+ return 0;
+}
+EXPORT_SYMBOL(ww_mutex_trylock);
+
#ifdef CONFIG_DEBUG_LOCK_ALLOC
void __sched
mutex_lock_nested(struct mutex *lock, unsigned int subclass)
--- a/kernel/locking/test-ww_mutex.c
+++ b/kernel/locking/test-ww_mutex.c
@@ -16,6 +16,15 @@
static DEFINE_WD_CLASS(ww_class);
struct workqueue_struct *wq;
+#ifdef CONFIG_DEBUG_WW_MUTEX_SLOWPATH
+#define ww_acquire_init_noinject(a, b) do { \
+ ww_acquire_init((a), (b)); \
+ (a)->deadlock_inject_countdown = ~0U; \
+ } while (0)
+#else
+#define ww_acquire_init_noinject(a, b) ww_acquire_init((a), (b))
+#endif
+
struct test_mutex {
struct work_struct work;
struct ww_mutex mutex;
@@ -36,7 +45,7 @@ static void test_mutex_work(struct work_
wait_for_completion(&mtx->go);
if (mtx->flags & TEST_MTX_TRY) {
- while (!ww_mutex_trylock(&mtx->mutex))
+ while (!ww_mutex_trylock(&mtx->mutex, NULL))
cond_resched();
} else {
ww_mutex_lock(&mtx->mutex, NULL);
@@ -109,19 +118,38 @@ static int test_mutex(void)
return 0;
}
-static int test_aa(void)
+static int test_aa(bool trylock)
{
struct ww_mutex mutex;
struct ww_acquire_ctx ctx;
int ret;
+ const char *from = trylock ? "trylock" : "lock";
ww_mutex_init(&mutex, &ww_class);
ww_acquire_init(&ctx, &ww_class);
- ww_mutex_lock(&mutex, &ctx);
+ if (!trylock) {
+ ret = ww_mutex_lock(&mutex, &ctx);
+ if (ret) {
+ pr_err("%s: initial lock failed!\n", __func__);
+ goto out;
+ }
+ } else {
+ if (!ww_mutex_trylock(&mutex, &ctx)) {
+ pr_err("%s: initial trylock failed!\n", __func__);
+ goto out;
+ }
+ }
- if (ww_mutex_trylock(&mutex)) {
- pr_err("%s: trylocked itself!\n", __func__);
+ if (ww_mutex_trylock(&mutex, NULL)) {
+ pr_err("%s: trylocked itself without context from %s!\n", __func__, from);
+ ww_mutex_unlock(&mutex);
+ ret = -EINVAL;
+ goto out;
+ }
+
+ if (ww_mutex_trylock(&mutex, &ctx)) {
+ pr_err("%s: trylocked itself with context from %s!\n", __func__, from);
ww_mutex_unlock(&mutex);
ret = -EINVAL;
goto out;
@@ -129,17 +157,17 @@ static int test_aa(void)
ret = ww_mutex_lock(&mutex, &ctx);
if (ret != -EALREADY) {
- pr_err("%s: missed deadlock for recursing, ret=%d\n",
- __func__, ret);
+ pr_err("%s: missed deadlock for recursing, ret=%d from %s\n",
+ __func__, ret, from);
if (!ret)
ww_mutex_unlock(&mutex);
ret = -EINVAL;
goto out;
}
+ ww_mutex_unlock(&mutex);
ret = 0;
out:
- ww_mutex_unlock(&mutex);
ww_acquire_fini(&ctx);
return ret;
}
@@ -150,7 +178,7 @@ struct test_abba {
struct ww_mutex b_mutex;
struct completion a_ready;
struct completion b_ready;
- bool resolve;
+ bool resolve, trylock;
int result;
};
@@ -160,8 +188,13 @@ static void test_abba_work(struct work_s
struct ww_acquire_ctx ctx;
int err;
- ww_acquire_init(&ctx, &ww_class);
- ww_mutex_lock(&abba->b_mutex, &ctx);
+ ww_acquire_init_noinject(&ctx, &ww_class);
+ if (!abba->trylock)
+ ww_mutex_lock(&abba->b_mutex, &ctx);
+ else
+ WARN_ON(!ww_mutex_trylock(&abba->b_mutex, &ctx));
+
+ WARN_ON(READ_ONCE(abba->b_mutex.ctx) != &ctx);
complete(&abba->b_ready);
wait_for_completion(&abba->a_ready);
@@ -181,7 +214,7 @@ static void test_abba_work(struct work_s
abba->result = err;
}
-static int test_abba(bool resolve)
+static int test_abba(bool trylock, bool resolve)
{
struct test_abba abba;
struct ww_acquire_ctx ctx;
@@ -192,12 +225,18 @@ static int test_abba(bool resolve)
INIT_WORK_ONSTACK(&abba.work, test_abba_work);
init_completion(&abba.a_ready);
init_completion(&abba.b_ready);
+ abba.trylock = trylock;
abba.resolve = resolve;
schedule_work(&abba.work);
- ww_acquire_init(&ctx, &ww_class);
- ww_mutex_lock(&abba.a_mutex, &ctx);
+ ww_acquire_init_noinject(&ctx, &ww_class);
+ if (!trylock)
+ ww_mutex_lock(&abba.a_mutex, &ctx);
+ else
+ WARN_ON(!ww_mutex_trylock(&abba.a_mutex, &ctx));
+
+ WARN_ON(READ_ONCE(abba.a_mutex.ctx) != &ctx);
complete(&abba.a_ready);
wait_for_completion(&abba.b_ready);
@@ -249,7 +288,7 @@ static void test_cycle_work(struct work_
struct ww_acquire_ctx ctx;
int err, erra = 0;
- ww_acquire_init(&ctx, &ww_class);
+ ww_acquire_init_noinject(&ctx, &ww_class);
ww_mutex_lock(&cycle->a_mutex, &ctx);
complete(cycle->a_signal);
@@ -581,7 +620,9 @@ static int stress(int nlocks, int nthrea
static int __init test_ww_mutex_init(void)
{
int ncpus = num_online_cpus();
- int ret;
+ int ret, i;
+
+ printk(KERN_INFO "Beginning ww mutex selftests\n");
wq = alloc_workqueue("test-ww_mutex", WQ_UNBOUND, 0);
if (!wq)
@@ -591,17 +632,19 @@ static int __init test_ww_mutex_init(voi
if (ret)
return ret;
- ret = test_aa();
+ ret = test_aa(false);
if (ret)
return ret;
- ret = test_abba(false);
+ ret = test_aa(true);
if (ret)
return ret;
- ret = test_abba(true);
- if (ret)
- return ret;
+ for (i = 0; i < 4; i++) {
+ ret = test_abba(i & 1, i & 2);
+ if (ret)
+ return ret;
+ }
ret = test_cycle(ncpus);
if (ret)
@@ -619,6 +662,7 @@ static int __init test_ww_mutex_init(voi
if (ret)
return ret;
+ printk(KERN_INFO "All ww mutex selftests passed\n");
return 0;
}
--- a/kernel/locking/ww_rt_mutex.c
+++ b/kernel/locking/ww_rt_mutex.c
@@ -9,6 +9,31 @@
#define WW_RT
#include "rtmutex.c"
+int ww_mutex_trylock(struct ww_mutex *lock, struct ww_acquire_ctx *ww_ctx)
+{
+ struct rt_mutex *rtm = &lock->base;
+
+ if (!ww_ctx)
+ return rt_mutex_trylock(rtm);
+
+ /*
+ * Reset the wounded flag after a kill. No other process can
+ * race and wound us here, since they can't have a valid owner
+ * pointer if we don't have any locks held.
+ */
+ if (ww_ctx->acquired == 0)
+ ww_ctx->wounded = 0;
+
+ if (__rt_mutex_trylock(&rtm->rtmutex)) {
+ ww_mutex_set_context_fastpath(lock, ww_ctx);
+ mutex_acquire_nest(&rtm->dep_map, 0, 1, ww_ctx->dep_map, _RET_IP_);
+ return 1;
+ }
+
+ return 0;
+}
+EXPORT_SYMBOL(ww_mutex_trylock);
+
static int __sched
__ww_rt_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ww_ctx,
unsigned int state, unsigned long ip)
--- a/lib/locking-selftest.c
+++ b/lib/locking-selftest.c
@@ -258,7 +258,7 @@ static void init_shared_classes(void)
#define WWAF(x) ww_acquire_fini(x)
#define WWL(x, c) ww_mutex_lock(x, c)
-#define WWT(x) ww_mutex_trylock(x)
+#define WWT(x) ww_mutex_trylock(x, NULL)
#define WWL1(x) ww_mutex_lock(x, NULL)
#define WWU(x) ww_mutex_unlock(x)
^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v2] kernel/locking: Add context to ww_mutex_trylock.
2021-09-14 6:50 ` Peter Zijlstra
@ 2021-09-14 12:43 ` Maarten Lankhorst
2021-09-14 13:54 ` Daniel Vetter
2021-11-04 12:27 ` [PATCH] kernel/locking: Use a pointer in ww_mutex_trylock() Sebastian Andrzej Siewior
1 sibling, 1 reply; 20+ messages in thread
From: Maarten Lankhorst @ 2021-09-14 12:43 UTC (permalink / raw)
To: Peter Zijlstra
Cc: intel-gfx, dri-devel, Ingo Molnar, Will Deacon, Waiman Long,
Boqun Feng, Liam Girdwood, Mark Brown, linux-kernel,
Daniel Vetter
Op 14-09-2021 om 08:50 schreef Peter Zijlstra:
> On Mon, Sep 13, 2021 at 10:42:36AM +0200, Maarten Lankhorst wrote:
>
>>> +/**
>>> + * ww_mutex_trylock - tries to acquire the w/w mutex with optional acquire context
>>> + * @ww: mutex to lock
>>> + * @ww_ctx: optional w/w acquire context
>>> + *
>>> + * Trylocks a mutex with the optional acquire context; no deadlock detection is
>>> + * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
>>> + *
>>> + * Unlike ww_mutex_lock, no deadlock handling is performed. However, if a @ctx is
>>> + * specified, -EALREADY handling may happen in calls to ww_mutex_trylock.
>>> + *
>>> + * A mutex acquired with this function must be released with ww_mutex_unlock.
>>> + */
>>> +int ww_mutex_trylock(struct ww_mutex *ww, struct ww_acquire_ctx *ww_ctx)
>>> +{
>>> + if (!ww_ctx)
>>> + return mutex_trylock(&ww->base);
>>> +
>>> + MUTEX_WARN_ON(ww->base.magic != &ww->base);
>>> +
>>> + if (unlikely(ww_ctx == READ_ONCE(ww->ctx)))
>>> + return -EALREADY;
>> I'm not 100% sure this is a good idea, because it would make the
>> trylock weird. For i915 I checked manually, because I didn't want to
>> change the function signature. This is probably the other extreme.
>>
>> "if (ww_mutex_trylock())" would look correct, but actually be wrong
>> and lead to double unlock without adjustments. Maybe we could make a
>> ww_mutex_trylock_ctx_err, which would return -EALREADY or -EBUSY on
>> failure, and 0 on success? We could keep ww_mutex_trylock without
>> ctx, probably just #define as (!ww_mutex_trylock_ctx_err(lock, NULL))
> Urgh, yeah. Also, I suppose that if we already own it, we'll just fail
> the trylock anyway. Let me take this out.
>
>>> + /*
>>> + * Reset the wounded flag after a kill. No other process can
>>> + * race and wound us here, since they can't have a valid owner
>>> + * pointer if we don't have any locks held.
>>> + */
>>> + if (ww_ctx->acquired == 0)
>>> + ww_ctx->wounded = 0;
>> Yeah I guess this needs fixing too. Not completely sure since trylock
>> wouldn't do the whole ww dance, but since it's our first lock,
>> probably best to do so regardless so other users don't trip over it.
> This is actually critical, because if this trylock is the first lock
> acquisition for the context, there won't be any other opportunity to
> reset this value.
>
>>> +
>>> + if (__mutex_trylock(&ww->base)) {
>>> + ww_mutex_set_context_fastpath(ww, ww_ctx);
>>> + mutex_acquire_nest(&ww->base.dep_map, 0, 1, &ww_ctx->dep_map, _RET_IP_);
>>> + return 1;
>>> + }
>>> +
>>> + return 0;
>>> +}
>>> +EXPORT_SYMBOL(ww_mutex_trylock);
> Updated version below...
>
> ---
> Subject: kernel/locking: Add context to ww_mutex_trylock()
> From: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
> Date: Thu, 9 Sep 2021 11:32:18 +0200
>
> From: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
>
> i915 will soon gain an eviction path that trylock a whole lot of locks
> for eviction, getting dmesg failures like below:
>
> BUG: MAX_LOCK_DEPTH too low!
> turning off the locking correctness validator.
> depth: 48 max: 48!
> 48 locks held by i915_selftest/5776:
> #0: ffff888101a79240 (&dev->mutex){....}-{3:3}, at: __driver_attach+0x88/0x160
> #1: ffffc900009778c0 (reservation_ww_class_acquire){+.+.}-{0:0}, at: i915_vma_pin.constprop.63+0x39/0x1b0 [i915]
> #2: ffff88800cf74de8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_vma_pin.constprop.63+0x5f/0x1b0 [i915]
> #3: ffff88810c7f9e38 (&vm->mutex/1){+.+.}-{3:3}, at: i915_vma_pin_ww+0x1c4/0x9d0 [i915]
> #4: ffff88810bad5768 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
> #5: ffff88810bad60e8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
> ...
> #46: ffff88811964d768 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
> #47: ffff88811964e0e8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
> INFO: lockdep is turned off.
>
> Fixing eviction to nest into ww_class_acquire is a high priority, but
> it requires a rework of the entire driver, which can only be done one
> step at a time.
>
> As an intermediate solution, add an acquire context to
> ww_mutex_trylock, which allows us to do proper nesting annotations on
> the trylocks, making the above lockdep splat disappear.
>
> This is also useful in regulator_lock_nested, which may avoid dropping
> regulator_nesting_mutex in the uncontended path, so use it there.
>
> TTM may be another user for this, where we could lock a buffer in a
> fastpath with list locks held, without dropping all locks we hold.
>
> [peterz: rework actual ww_mutex_trylock() implementations]
> Signed-off-by: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
> Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
> ---
My original patch series with this patch in place still passes i915 selftests, looks good to me. :)
Feel free to apply.
> drivers/gpu/drm/drm_modeset_lock.c | 2
> drivers/regulator/core.c | 2
> include/linux/dma-resv.h | 2
> include/linux/ww_mutex.h | 15 ------
> kernel/locking/mutex.c | 41 +++++++++++++++++
> kernel/locking/test-ww_mutex.c | 86 +++++++++++++++++++++++++++----------
> kernel/locking/ww_rt_mutex.c | 25 ++++++++++
> lib/locking-selftest.c | 2
> 8 files changed, 137 insertions(+), 38 deletions(-)
>
> --- a/drivers/gpu/drm/drm_modeset_lock.c
> +++ b/drivers/gpu/drm/drm_modeset_lock.c
> @@ -248,7 +248,7 @@ static inline int modeset_lock(struct dr
> if (ctx->trylock_only) {
> lockdep_assert_held(&ctx->ww_ctx);
>
> - if (!ww_mutex_trylock(&lock->mutex))
> + if (!ww_mutex_trylock(&lock->mutex, NULL))
> return -EBUSY;
> else
> return 0;
> --- a/drivers/regulator/core.c
> +++ b/drivers/regulator/core.c
> @@ -145,7 +145,7 @@ static inline int regulator_lock_nested(
>
> mutex_lock(®ulator_nesting_mutex);
>
> - if (ww_ctx || !ww_mutex_trylock(&rdev->mutex)) {
> + if (!ww_mutex_trylock(&rdev->mutex, ww_ctx)) {
> if (rdev->mutex_owner == current)
> rdev->ref_cnt++;
> else
> --- a/include/linux/dma-resv.h
> +++ b/include/linux/dma-resv.h
> @@ -173,7 +173,7 @@ static inline int dma_resv_lock_slow_int
> */
> static inline bool __must_check dma_resv_trylock(struct dma_resv *obj)
> {
> - return ww_mutex_trylock(&obj->lock);
> + return ww_mutex_trylock(&obj->lock, NULL);
> }
>
> /**
> --- a/include/linux/ww_mutex.h
> +++ b/include/linux/ww_mutex.h
> @@ -28,12 +28,10 @@
> #ifndef CONFIG_PREEMPT_RT
> #define WW_MUTEX_BASE mutex
> #define ww_mutex_base_init(l,n,k) __mutex_init(l,n,k)
> -#define ww_mutex_base_trylock(l) mutex_trylock(l)
> #define ww_mutex_base_is_locked(b) mutex_is_locked((b))
> #else
> #define WW_MUTEX_BASE rt_mutex
> #define ww_mutex_base_init(l,n,k) __rt_mutex_init(l,n,k)
> -#define ww_mutex_base_trylock(l) rt_mutex_trylock(l)
> #define ww_mutex_base_is_locked(b) rt_mutex_base_is_locked(&(b)->rtmutex)
> #endif
>
> @@ -339,17 +337,8 @@ ww_mutex_lock_slow_interruptible(struct
>
> extern void ww_mutex_unlock(struct ww_mutex *lock);
>
> -/**
> - * ww_mutex_trylock - tries to acquire the w/w mutex without acquire context
> - * @lock: mutex to lock
> - *
> - * Trylocks a mutex without acquire context, so no deadlock detection is
> - * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
> - */
> -static inline int __must_check ww_mutex_trylock(struct ww_mutex *lock)
> -{
> - return ww_mutex_base_trylock(&lock->base);
> -}
> +extern int __must_check ww_mutex_trylock(struct ww_mutex *lock,
> + struct ww_acquire_ctx *ctx);
>
> /***
> * ww_mutex_destroy - mark a w/w mutex unusable
> --- a/kernel/locking/mutex.c
> +++ b/kernel/locking/mutex.c
> @@ -94,6 +94,9 @@ static inline unsigned long __owner_flag
> return owner & MUTEX_FLAGS;
> }
>
> +/*
> + * Returns: __mutex_owner(lock) on failure or NULL on success.
> + */
> static inline struct task_struct *__mutex_trylock_common(struct mutex *lock, bool handoff)
> {
> unsigned long owner, curr = (unsigned long)current;
> @@ -736,6 +739,44 @@ __ww_mutex_lock(struct mutex *lock, unsi
> return __mutex_lock_common(lock, state, subclass, NULL, ip, ww_ctx, true);
> }
>
> +/**
> + * ww_mutex_trylock - tries to acquire the w/w mutex with optional acquire context
> + * @ww: mutex to lock
> + * @ww_ctx: optional w/w acquire context
> + *
> + * Trylocks a mutex with the optional acquire context; no deadlock detection is
> + * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
> + *
> + * Unlike ww_mutex_lock, no deadlock handling is performed. However, if a @ctx is
> + * specified, -EALREADY handling may happen in calls to ww_mutex_trylock.
> + *
> + * A mutex acquired with this function must be released with ww_mutex_unlock.
> + */
> +int ww_mutex_trylock(struct ww_mutex *ww, struct ww_acquire_ctx *ww_ctx)
> +{
> + if (!ww_ctx)
> + return mutex_trylock(&ww->base);
> +
> + MUTEX_WARN_ON(ww->base.magic != &ww->base);
> +
> + /*
> + * Reset the wounded flag after a kill. No other process can
> + * race and wound us here, since they can't have a valid owner
> + * pointer if we don't have any locks held.
> + */
> + if (ww_ctx->acquired == 0)
> + ww_ctx->wounded = 0;
> +
> + if (__mutex_trylock(&ww->base)) {
> + ww_mutex_set_context_fastpath(ww, ww_ctx);
> + mutex_acquire_nest(&ww->base.dep_map, 0, 1, &ww_ctx->dep_map, _RET_IP_);
> + return 1;
> + }
> +
> + return 0;
> +}
> +EXPORT_SYMBOL(ww_mutex_trylock);
> +
> #ifdef CONFIG_DEBUG_LOCK_ALLOC
> void __sched
> mutex_lock_nested(struct mutex *lock, unsigned int subclass)
> --- a/kernel/locking/test-ww_mutex.c
> +++ b/kernel/locking/test-ww_mutex.c
> @@ -16,6 +16,15 @@
> static DEFINE_WD_CLASS(ww_class);
> struct workqueue_struct *wq;
>
> +#ifdef CONFIG_DEBUG_WW_MUTEX_SLOWPATH
> +#define ww_acquire_init_noinject(a, b) do { \
> + ww_acquire_init((a), (b)); \
> + (a)->deadlock_inject_countdown = ~0U; \
> + } while (0)
> +#else
> +#define ww_acquire_init_noinject(a, b) ww_acquire_init((a), (b))
> +#endif
> +
> struct test_mutex {
> struct work_struct work;
> struct ww_mutex mutex;
> @@ -36,7 +45,7 @@ static void test_mutex_work(struct work_
> wait_for_completion(&mtx->go);
>
> if (mtx->flags & TEST_MTX_TRY) {
> - while (!ww_mutex_trylock(&mtx->mutex))
> + while (!ww_mutex_trylock(&mtx->mutex, NULL))
> cond_resched();
> } else {
> ww_mutex_lock(&mtx->mutex, NULL);
> @@ -109,19 +118,38 @@ static int test_mutex(void)
> return 0;
> }
>
> -static int test_aa(void)
> +static int test_aa(bool trylock)
> {
> struct ww_mutex mutex;
> struct ww_acquire_ctx ctx;
> int ret;
> + const char *from = trylock ? "trylock" : "lock";
>
> ww_mutex_init(&mutex, &ww_class);
> ww_acquire_init(&ctx, &ww_class);
>
> - ww_mutex_lock(&mutex, &ctx);
> + if (!trylock) {
> + ret = ww_mutex_lock(&mutex, &ctx);
> + if (ret) {
> + pr_err("%s: initial lock failed!\n", __func__);
> + goto out;
> + }
> + } else {
> + if (!ww_mutex_trylock(&mutex, &ctx)) {
> + pr_err("%s: initial trylock failed!\n", __func__);
> + goto out;
> + }
> + }
>
> - if (ww_mutex_trylock(&mutex)) {
> - pr_err("%s: trylocked itself!\n", __func__);
> + if (ww_mutex_trylock(&mutex, NULL)) {
> + pr_err("%s: trylocked itself without context from %s!\n", __func__, from);
> + ww_mutex_unlock(&mutex);
> + ret = -EINVAL;
> + goto out;
> + }
> +
> + if (ww_mutex_trylock(&mutex, &ctx)) {
> + pr_err("%s: trylocked itself with context from %s!\n", __func__, from);
> ww_mutex_unlock(&mutex);
> ret = -EINVAL;
> goto out;
> @@ -129,17 +157,17 @@ static int test_aa(void)
>
> ret = ww_mutex_lock(&mutex, &ctx);
> if (ret != -EALREADY) {
> - pr_err("%s: missed deadlock for recursing, ret=%d\n",
> - __func__, ret);
> + pr_err("%s: missed deadlock for recursing, ret=%d from %s\n",
> + __func__, ret, from);
> if (!ret)
> ww_mutex_unlock(&mutex);
> ret = -EINVAL;
> goto out;
> }
>
> + ww_mutex_unlock(&mutex);
> ret = 0;
> out:
> - ww_mutex_unlock(&mutex);
> ww_acquire_fini(&ctx);
> return ret;
> }
> @@ -150,7 +178,7 @@ struct test_abba {
> struct ww_mutex b_mutex;
> struct completion a_ready;
> struct completion b_ready;
> - bool resolve;
> + bool resolve, trylock;
> int result;
> };
>
> @@ -160,8 +188,13 @@ static void test_abba_work(struct work_s
> struct ww_acquire_ctx ctx;
> int err;
>
> - ww_acquire_init(&ctx, &ww_class);
> - ww_mutex_lock(&abba->b_mutex, &ctx);
> + ww_acquire_init_noinject(&ctx, &ww_class);
> + if (!abba->trylock)
> + ww_mutex_lock(&abba->b_mutex, &ctx);
> + else
> + WARN_ON(!ww_mutex_trylock(&abba->b_mutex, &ctx));
> +
> + WARN_ON(READ_ONCE(abba->b_mutex.ctx) != &ctx);
>
> complete(&abba->b_ready);
> wait_for_completion(&abba->a_ready);
> @@ -181,7 +214,7 @@ static void test_abba_work(struct work_s
> abba->result = err;
> }
>
> -static int test_abba(bool resolve)
> +static int test_abba(bool trylock, bool resolve)
> {
> struct test_abba abba;
> struct ww_acquire_ctx ctx;
> @@ -192,12 +225,18 @@ static int test_abba(bool resolve)
> INIT_WORK_ONSTACK(&abba.work, test_abba_work);
> init_completion(&abba.a_ready);
> init_completion(&abba.b_ready);
> + abba.trylock = trylock;
> abba.resolve = resolve;
>
> schedule_work(&abba.work);
>
> - ww_acquire_init(&ctx, &ww_class);
> - ww_mutex_lock(&abba.a_mutex, &ctx);
> + ww_acquire_init_noinject(&ctx, &ww_class);
> + if (!trylock)
> + ww_mutex_lock(&abba.a_mutex, &ctx);
> + else
> + WARN_ON(!ww_mutex_trylock(&abba.a_mutex, &ctx));
> +
> + WARN_ON(READ_ONCE(abba.a_mutex.ctx) != &ctx);
>
> complete(&abba.a_ready);
> wait_for_completion(&abba.b_ready);
> @@ -249,7 +288,7 @@ static void test_cycle_work(struct work_
> struct ww_acquire_ctx ctx;
> int err, erra = 0;
>
> - ww_acquire_init(&ctx, &ww_class);
> + ww_acquire_init_noinject(&ctx, &ww_class);
> ww_mutex_lock(&cycle->a_mutex, &ctx);
>
> complete(cycle->a_signal);
> @@ -581,7 +620,9 @@ static int stress(int nlocks, int nthrea
> static int __init test_ww_mutex_init(void)
> {
> int ncpus = num_online_cpus();
> - int ret;
> + int ret, i;
> +
> + printk(KERN_INFO "Beginning ww mutex selftests\n");
>
> wq = alloc_workqueue("test-ww_mutex", WQ_UNBOUND, 0);
> if (!wq)
> @@ -591,17 +632,19 @@ static int __init test_ww_mutex_init(voi
> if (ret)
> return ret;
>
> - ret = test_aa();
> + ret = test_aa(false);
> if (ret)
> return ret;
>
> - ret = test_abba(false);
> + ret = test_aa(true);
> if (ret)
> return ret;
>
> - ret = test_abba(true);
> - if (ret)
> - return ret;
> + for (i = 0; i < 4; i++) {
> + ret = test_abba(i & 1, i & 2);
> + if (ret)
> + return ret;
> + }
>
> ret = test_cycle(ncpus);
> if (ret)
> @@ -619,6 +662,7 @@ static int __init test_ww_mutex_init(voi
> if (ret)
> return ret;
>
> + printk(KERN_INFO "All ww mutex selftests passed\n");
> return 0;
> }
>
> --- a/kernel/locking/ww_rt_mutex.c
> +++ b/kernel/locking/ww_rt_mutex.c
> @@ -9,6 +9,31 @@
> #define WW_RT
> #include "rtmutex.c"
>
> +int ww_mutex_trylock(struct ww_mutex *lock, struct ww_acquire_ctx *ww_ctx)
> +{
> + struct rt_mutex *rtm = &lock->base;
> +
> + if (!ww_ctx)
> + return rt_mutex_trylock(rtm);
> +
> + /*
> + * Reset the wounded flag after a kill. No other process can
> + * race and wound us here, since they can't have a valid owner
> + * pointer if we don't have any locks held.
> + */
> + if (ww_ctx->acquired == 0)
> + ww_ctx->wounded = 0;
> +
> + if (__rt_mutex_trylock(&rtm->rtmutex)) {
> + ww_mutex_set_context_fastpath(lock, ww_ctx);
> + mutex_acquire_nest(&rtm->dep_map, 0, 1, ww_ctx->dep_map, _RET_IP_);
> + return 1;
> + }
> +
> + return 0;
> +}
> +EXPORT_SYMBOL(ww_mutex_trylock);
> +
> static int __sched
> __ww_rt_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ww_ctx,
> unsigned int state, unsigned long ip)
> --- a/lib/locking-selftest.c
> +++ b/lib/locking-selftest.c
> @@ -258,7 +258,7 @@ static void init_shared_classes(void)
> #define WWAF(x) ww_acquire_fini(x)
>
> #define WWL(x, c) ww_mutex_lock(x, c)
> -#define WWT(x) ww_mutex_trylock(x)
> +#define WWT(x) ww_mutex_trylock(x, NULL)
> #define WWL1(x) ww_mutex_lock(x, NULL)
> #define WWU(x) ww_mutex_unlock(x)
>
^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v2] kernel/locking: Add context to ww_mutex_trylock.
2021-09-14 12:43 ` Maarten Lankhorst
@ 2021-09-14 13:54 ` Daniel Vetter
2021-09-16 13:00 ` Maarten Lankhorst
0 siblings, 1 reply; 20+ messages in thread
From: Daniel Vetter @ 2021-09-14 13:54 UTC (permalink / raw)
To: Maarten Lankhorst
Cc: Peter Zijlstra, intel-gfx, dri-devel, Ingo Molnar, Will Deacon,
Waiman Long, Boqun Feng, Liam Girdwood, Mark Brown, linux-kernel,
Daniel Vetter
On Tue, Sep 14, 2021 at 02:43:02PM +0200, Maarten Lankhorst wrote:
> Op 14-09-2021 om 08:50 schreef Peter Zijlstra:
> > On Mon, Sep 13, 2021 at 10:42:36AM +0200, Maarten Lankhorst wrote:
> >
> >>> +/**
> >>> + * ww_mutex_trylock - tries to acquire the w/w mutex with optional acquire context
> >>> + * @ww: mutex to lock
> >>> + * @ww_ctx: optional w/w acquire context
> >>> + *
> >>> + * Trylocks a mutex with the optional acquire context; no deadlock detection is
> >>> + * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
> >>> + *
> >>> + * Unlike ww_mutex_lock, no deadlock handling is performed. However, if a @ctx is
> >>> + * specified, -EALREADY handling may happen in calls to ww_mutex_trylock.
> >>> + *
> >>> + * A mutex acquired with this function must be released with ww_mutex_unlock.
> >>> + */
> >>> +int ww_mutex_trylock(struct ww_mutex *ww, struct ww_acquire_ctx *ww_ctx)
> >>> +{
> >>> + if (!ww_ctx)
> >>> + return mutex_trylock(&ww->base);
> >>> +
> >>> + MUTEX_WARN_ON(ww->base.magic != &ww->base);
> >>> +
> >>> + if (unlikely(ww_ctx == READ_ONCE(ww->ctx)))
> >>> + return -EALREADY;
> >> I'm not 100% sure this is a good idea, because it would make the
> >> trylock weird. For i915 I checked manually, because I didn't want to
> >> change the function signature. This is probably the other extreme.
> >>
> >> "if (ww_mutex_trylock())" would look correct, but actually be wrong
> >> and lead to double unlock without adjustments. Maybe we could make a
> >> ww_mutex_trylock_ctx_err, which would return -EALREADY or -EBUSY on
> >> failure, and 0 on success? We could keep ww_mutex_trylock without
> >> ctx, probably just #define as (!ww_mutex_trylock_ctx_err(lock, NULL))
> > Urgh, yeah. Also, I suppose that if we already own it, we'll just fail
> > the trylock anyway. Let me take this out.
> >
> >>> + /*
> >>> + * Reset the wounded flag after a kill. No other process can
> >>> + * race and wound us here, since they can't have a valid owner
> >>> + * pointer if we don't have any locks held.
> >>> + */
> >>> + if (ww_ctx->acquired == 0)
> >>> + ww_ctx->wounded = 0;
> >> Yeah I guess this needs fixing too. Not completely sure since trylock
> >> wouldn't do the whole ww dance, but since it's our first lock,
> >> probably best to do so regardless so other users don't trip over it.
> > This is actually critical, because if this trylock is the first lock
> > acquisition for the context, there won't be any other opportunity to
> > reset this value.
> >
> >>> +
> >>> + if (__mutex_trylock(&ww->base)) {
> >>> + ww_mutex_set_context_fastpath(ww, ww_ctx);
> >>> + mutex_acquire_nest(&ww->base.dep_map, 0, 1, &ww_ctx->dep_map, _RET_IP_);
> >>> + return 1;
> >>> + }
> >>> +
> >>> + return 0;
> >>> +}
> >>> +EXPORT_SYMBOL(ww_mutex_trylock);
> > Updated version below...
> >
> > ---
> > Subject: kernel/locking: Add context to ww_mutex_trylock()
> > From: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
> > Date: Thu, 9 Sep 2021 11:32:18 +0200
> >
> > From: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
> >
> > i915 will soon gain an eviction path that trylock a whole lot of locks
> > for eviction, getting dmesg failures like below:
> >
> > BUG: MAX_LOCK_DEPTH too low!
> > turning off the locking correctness validator.
> > depth: 48 max: 48!
> > 48 locks held by i915_selftest/5776:
> > #0: ffff888101a79240 (&dev->mutex){....}-{3:3}, at: __driver_attach+0x88/0x160
> > #1: ffffc900009778c0 (reservation_ww_class_acquire){+.+.}-{0:0}, at: i915_vma_pin.constprop.63+0x39/0x1b0 [i915]
> > #2: ffff88800cf74de8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_vma_pin.constprop.63+0x5f/0x1b0 [i915]
> > #3: ffff88810c7f9e38 (&vm->mutex/1){+.+.}-{3:3}, at: i915_vma_pin_ww+0x1c4/0x9d0 [i915]
> > #4: ffff88810bad5768 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
> > #5: ffff88810bad60e8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
> > ...
> > #46: ffff88811964d768 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
> > #47: ffff88811964e0e8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
> > INFO: lockdep is turned off.
> >
> > Fixing eviction to nest into ww_class_acquire is a high priority, but
> > it requires a rework of the entire driver, which can only be done one
> > step at a time.
> >
> > As an intermediate solution, add an acquire context to
> > ww_mutex_trylock, which allows us to do proper nesting annotations on
> > the trylocks, making the above lockdep splat disappear.
> >
> > This is also useful in regulator_lock_nested, which may avoid dropping
> > regulator_nesting_mutex in the uncontended path, so use it there.
> >
> > TTM may be another user for this, where we could lock a buffer in a
> > fastpath with list locks held, without dropping all locks we hold.
> >
> > [peterz: rework actual ww_mutex_trylock() implementations]
> > Signed-off-by: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
> > Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
> > ---
>
> My original patch series with this patch in place still passes i915 selftests, looks good to me. :)
For merge logistics, can we pls have a stable branch? I expect that the
i915 patches will be ready for 5.16.
Or send it in for -rc2 so that the interface change doesn't cause needless
conflicts, whatever you think is best.
-Daniel
>
> Feel free to apply.
>
>
> > drivers/gpu/drm/drm_modeset_lock.c | 2
> > drivers/regulator/core.c | 2
> > include/linux/dma-resv.h | 2
> > include/linux/ww_mutex.h | 15 ------
> > kernel/locking/mutex.c | 41 +++++++++++++++++
> > kernel/locking/test-ww_mutex.c | 86 +++++++++++++++++++++++++++----------
> > kernel/locking/ww_rt_mutex.c | 25 ++++++++++
> > lib/locking-selftest.c | 2
> > 8 files changed, 137 insertions(+), 38 deletions(-)
> >
> > --- a/drivers/gpu/drm/drm_modeset_lock.c
> > +++ b/drivers/gpu/drm/drm_modeset_lock.c
> > @@ -248,7 +248,7 @@ static inline int modeset_lock(struct dr
> > if (ctx->trylock_only) {
> > lockdep_assert_held(&ctx->ww_ctx);
> >
> > - if (!ww_mutex_trylock(&lock->mutex))
> > + if (!ww_mutex_trylock(&lock->mutex, NULL))
> > return -EBUSY;
> > else
> > return 0;
> > --- a/drivers/regulator/core.c
> > +++ b/drivers/regulator/core.c
> > @@ -145,7 +145,7 @@ static inline int regulator_lock_nested(
> >
> > mutex_lock(®ulator_nesting_mutex);
> >
> > - if (ww_ctx || !ww_mutex_trylock(&rdev->mutex)) {
> > + if (!ww_mutex_trylock(&rdev->mutex, ww_ctx)) {
> > if (rdev->mutex_owner == current)
> > rdev->ref_cnt++;
> > else
> > --- a/include/linux/dma-resv.h
> > +++ b/include/linux/dma-resv.h
> > @@ -173,7 +173,7 @@ static inline int dma_resv_lock_slow_int
> > */
> > static inline bool __must_check dma_resv_trylock(struct dma_resv *obj)
> > {
> > - return ww_mutex_trylock(&obj->lock);
> > + return ww_mutex_trylock(&obj->lock, NULL);
> > }
> >
> > /**
> > --- a/include/linux/ww_mutex.h
> > +++ b/include/linux/ww_mutex.h
> > @@ -28,12 +28,10 @@
> > #ifndef CONFIG_PREEMPT_RT
> > #define WW_MUTEX_BASE mutex
> > #define ww_mutex_base_init(l,n,k) __mutex_init(l,n,k)
> > -#define ww_mutex_base_trylock(l) mutex_trylock(l)
> > #define ww_mutex_base_is_locked(b) mutex_is_locked((b))
> > #else
> > #define WW_MUTEX_BASE rt_mutex
> > #define ww_mutex_base_init(l,n,k) __rt_mutex_init(l,n,k)
> > -#define ww_mutex_base_trylock(l) rt_mutex_trylock(l)
> > #define ww_mutex_base_is_locked(b) rt_mutex_base_is_locked(&(b)->rtmutex)
> > #endif
> >
> > @@ -339,17 +337,8 @@ ww_mutex_lock_slow_interruptible(struct
> >
> > extern void ww_mutex_unlock(struct ww_mutex *lock);
> >
> > -/**
> > - * ww_mutex_trylock - tries to acquire the w/w mutex without acquire context
> > - * @lock: mutex to lock
> > - *
> > - * Trylocks a mutex without acquire context, so no deadlock detection is
> > - * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
> > - */
> > -static inline int __must_check ww_mutex_trylock(struct ww_mutex *lock)
> > -{
> > - return ww_mutex_base_trylock(&lock->base);
> > -}
> > +extern int __must_check ww_mutex_trylock(struct ww_mutex *lock,
> > + struct ww_acquire_ctx *ctx);
> >
> > /***
> > * ww_mutex_destroy - mark a w/w mutex unusable
> > --- a/kernel/locking/mutex.c
> > +++ b/kernel/locking/mutex.c
> > @@ -94,6 +94,9 @@ static inline unsigned long __owner_flag
> > return owner & MUTEX_FLAGS;
> > }
> >
> > +/*
> > + * Returns: __mutex_owner(lock) on failure or NULL on success.
> > + */
> > static inline struct task_struct *__mutex_trylock_common(struct mutex *lock, bool handoff)
> > {
> > unsigned long owner, curr = (unsigned long)current;
> > @@ -736,6 +739,44 @@ __ww_mutex_lock(struct mutex *lock, unsi
> > return __mutex_lock_common(lock, state, subclass, NULL, ip, ww_ctx, true);
> > }
> >
> > +/**
> > + * ww_mutex_trylock - tries to acquire the w/w mutex with optional acquire context
> > + * @ww: mutex to lock
> > + * @ww_ctx: optional w/w acquire context
> > + *
> > + * Trylocks a mutex with the optional acquire context; no deadlock detection is
> > + * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
> > + *
> > + * Unlike ww_mutex_lock, no deadlock handling is performed. However, if a @ctx is
> > + * specified, -EALREADY handling may happen in calls to ww_mutex_trylock.
> > + *
> > + * A mutex acquired with this function must be released with ww_mutex_unlock.
> > + */
> > +int ww_mutex_trylock(struct ww_mutex *ww, struct ww_acquire_ctx *ww_ctx)
> > +{
> > + if (!ww_ctx)
> > + return mutex_trylock(&ww->base);
> > +
> > + MUTEX_WARN_ON(ww->base.magic != &ww->base);
> > +
> > + /*
> > + * Reset the wounded flag after a kill. No other process can
> > + * race and wound us here, since they can't have a valid owner
> > + * pointer if we don't have any locks held.
> > + */
> > + if (ww_ctx->acquired == 0)
> > + ww_ctx->wounded = 0;
> > +
> > + if (__mutex_trylock(&ww->base)) {
> > + ww_mutex_set_context_fastpath(ww, ww_ctx);
> > + mutex_acquire_nest(&ww->base.dep_map, 0, 1, &ww_ctx->dep_map, _RET_IP_);
> > + return 1;
> > + }
> > +
> > + return 0;
> > +}
> > +EXPORT_SYMBOL(ww_mutex_trylock);
> > +
> > #ifdef CONFIG_DEBUG_LOCK_ALLOC
> > void __sched
> > mutex_lock_nested(struct mutex *lock, unsigned int subclass)
> > --- a/kernel/locking/test-ww_mutex.c
> > +++ b/kernel/locking/test-ww_mutex.c
> > @@ -16,6 +16,15 @@
> > static DEFINE_WD_CLASS(ww_class);
> > struct workqueue_struct *wq;
> >
> > +#ifdef CONFIG_DEBUG_WW_MUTEX_SLOWPATH
> > +#define ww_acquire_init_noinject(a, b) do { \
> > + ww_acquire_init((a), (b)); \
> > + (a)->deadlock_inject_countdown = ~0U; \
> > + } while (0)
> > +#else
> > +#define ww_acquire_init_noinject(a, b) ww_acquire_init((a), (b))
> > +#endif
> > +
> > struct test_mutex {
> > struct work_struct work;
> > struct ww_mutex mutex;
> > @@ -36,7 +45,7 @@ static void test_mutex_work(struct work_
> > wait_for_completion(&mtx->go);
> >
> > if (mtx->flags & TEST_MTX_TRY) {
> > - while (!ww_mutex_trylock(&mtx->mutex))
> > + while (!ww_mutex_trylock(&mtx->mutex, NULL))
> > cond_resched();
> > } else {
> > ww_mutex_lock(&mtx->mutex, NULL);
> > @@ -109,19 +118,38 @@ static int test_mutex(void)
> > return 0;
> > }
> >
> > -static int test_aa(void)
> > +static int test_aa(bool trylock)
> > {
> > struct ww_mutex mutex;
> > struct ww_acquire_ctx ctx;
> > int ret;
> > + const char *from = trylock ? "trylock" : "lock";
> >
> > ww_mutex_init(&mutex, &ww_class);
> > ww_acquire_init(&ctx, &ww_class);
> >
> > - ww_mutex_lock(&mutex, &ctx);
> > + if (!trylock) {
> > + ret = ww_mutex_lock(&mutex, &ctx);
> > + if (ret) {
> > + pr_err("%s: initial lock failed!\n", __func__);
> > + goto out;
> > + }
> > + } else {
> > + if (!ww_mutex_trylock(&mutex, &ctx)) {
> > + pr_err("%s: initial trylock failed!\n", __func__);
> > + goto out;
> > + }
> > + }
> >
> > - if (ww_mutex_trylock(&mutex)) {
> > - pr_err("%s: trylocked itself!\n", __func__);
> > + if (ww_mutex_trylock(&mutex, NULL)) {
> > + pr_err("%s: trylocked itself without context from %s!\n", __func__, from);
> > + ww_mutex_unlock(&mutex);
> > + ret = -EINVAL;
> > + goto out;
> > + }
> > +
> > + if (ww_mutex_trylock(&mutex, &ctx)) {
> > + pr_err("%s: trylocked itself with context from %s!\n", __func__, from);
> > ww_mutex_unlock(&mutex);
> > ret = -EINVAL;
> > goto out;
> > @@ -129,17 +157,17 @@ static int test_aa(void)
> >
> > ret = ww_mutex_lock(&mutex, &ctx);
> > if (ret != -EALREADY) {
> > - pr_err("%s: missed deadlock for recursing, ret=%d\n",
> > - __func__, ret);
> > + pr_err("%s: missed deadlock for recursing, ret=%d from %s\n",
> > + __func__, ret, from);
> > if (!ret)
> > ww_mutex_unlock(&mutex);
> > ret = -EINVAL;
> > goto out;
> > }
> >
> > + ww_mutex_unlock(&mutex);
> > ret = 0;
> > out:
> > - ww_mutex_unlock(&mutex);
> > ww_acquire_fini(&ctx);
> > return ret;
> > }
> > @@ -150,7 +178,7 @@ struct test_abba {
> > struct ww_mutex b_mutex;
> > struct completion a_ready;
> > struct completion b_ready;
> > - bool resolve;
> > + bool resolve, trylock;
> > int result;
> > };
> >
> > @@ -160,8 +188,13 @@ static void test_abba_work(struct work_s
> > struct ww_acquire_ctx ctx;
> > int err;
> >
> > - ww_acquire_init(&ctx, &ww_class);
> > - ww_mutex_lock(&abba->b_mutex, &ctx);
> > + ww_acquire_init_noinject(&ctx, &ww_class);
> > + if (!abba->trylock)
> > + ww_mutex_lock(&abba->b_mutex, &ctx);
> > + else
> > + WARN_ON(!ww_mutex_trylock(&abba->b_mutex, &ctx));
> > +
> > + WARN_ON(READ_ONCE(abba->b_mutex.ctx) != &ctx);
> >
> > complete(&abba->b_ready);
> > wait_for_completion(&abba->a_ready);
> > @@ -181,7 +214,7 @@ static void test_abba_work(struct work_s
> > abba->result = err;
> > }
> >
> > -static int test_abba(bool resolve)
> > +static int test_abba(bool trylock, bool resolve)
> > {
> > struct test_abba abba;
> > struct ww_acquire_ctx ctx;
> > @@ -192,12 +225,18 @@ static int test_abba(bool resolve)
> > INIT_WORK_ONSTACK(&abba.work, test_abba_work);
> > init_completion(&abba.a_ready);
> > init_completion(&abba.b_ready);
> > + abba.trylock = trylock;
> > abba.resolve = resolve;
> >
> > schedule_work(&abba.work);
> >
> > - ww_acquire_init(&ctx, &ww_class);
> > - ww_mutex_lock(&abba.a_mutex, &ctx);
> > + ww_acquire_init_noinject(&ctx, &ww_class);
> > + if (!trylock)
> > + ww_mutex_lock(&abba.a_mutex, &ctx);
> > + else
> > + WARN_ON(!ww_mutex_trylock(&abba.a_mutex, &ctx));
> > +
> > + WARN_ON(READ_ONCE(abba.a_mutex.ctx) != &ctx);
> >
> > complete(&abba.a_ready);
> > wait_for_completion(&abba.b_ready);
> > @@ -249,7 +288,7 @@ static void test_cycle_work(struct work_
> > struct ww_acquire_ctx ctx;
> > int err, erra = 0;
> >
> > - ww_acquire_init(&ctx, &ww_class);
> > + ww_acquire_init_noinject(&ctx, &ww_class);
> > ww_mutex_lock(&cycle->a_mutex, &ctx);
> >
> > complete(cycle->a_signal);
> > @@ -581,7 +620,9 @@ static int stress(int nlocks, int nthrea
> > static int __init test_ww_mutex_init(void)
> > {
> > int ncpus = num_online_cpus();
> > - int ret;
> > + int ret, i;
> > +
> > + printk(KERN_INFO "Beginning ww mutex selftests\n");
> >
> > wq = alloc_workqueue("test-ww_mutex", WQ_UNBOUND, 0);
> > if (!wq)
> > @@ -591,17 +632,19 @@ static int __init test_ww_mutex_init(voi
> > if (ret)
> > return ret;
> >
> > - ret = test_aa();
> > + ret = test_aa(false);
> > if (ret)
> > return ret;
> >
> > - ret = test_abba(false);
> > + ret = test_aa(true);
> > if (ret)
> > return ret;
> >
> > - ret = test_abba(true);
> > - if (ret)
> > - return ret;
> > + for (i = 0; i < 4; i++) {
> > + ret = test_abba(i & 1, i & 2);
> > + if (ret)
> > + return ret;
> > + }
> >
> > ret = test_cycle(ncpus);
> > if (ret)
> > @@ -619,6 +662,7 @@ static int __init test_ww_mutex_init(voi
> > if (ret)
> > return ret;
> >
> > + printk(KERN_INFO "All ww mutex selftests passed\n");
> > return 0;
> > }
> >
> > --- a/kernel/locking/ww_rt_mutex.c
> > +++ b/kernel/locking/ww_rt_mutex.c
> > @@ -9,6 +9,31 @@
> > #define WW_RT
> > #include "rtmutex.c"
> >
> > +int ww_mutex_trylock(struct ww_mutex *lock, struct ww_acquire_ctx *ww_ctx)
> > +{
> > + struct rt_mutex *rtm = &lock->base;
> > +
> > + if (!ww_ctx)
> > + return rt_mutex_trylock(rtm);
> > +
> > + /*
> > + * Reset the wounded flag after a kill. No other process can
> > + * race and wound us here, since they can't have a valid owner
> > + * pointer if we don't have any locks held.
> > + */
> > + if (ww_ctx->acquired == 0)
> > + ww_ctx->wounded = 0;
> > +
> > + if (__rt_mutex_trylock(&rtm->rtmutex)) {
> > + ww_mutex_set_context_fastpath(lock, ww_ctx);
> > + mutex_acquire_nest(&rtm->dep_map, 0, 1, ww_ctx->dep_map, _RET_IP_);
> > + return 1;
> > + }
> > +
> > + return 0;
> > +}
> > +EXPORT_SYMBOL(ww_mutex_trylock);
> > +
> > static int __sched
> > __ww_rt_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ww_ctx,
> > unsigned int state, unsigned long ip)
> > --- a/lib/locking-selftest.c
> > +++ b/lib/locking-selftest.c
> > @@ -258,7 +258,7 @@ static void init_shared_classes(void)
> > #define WWAF(x) ww_acquire_fini(x)
> >
> > #define WWL(x, c) ww_mutex_lock(x, c)
> > -#define WWT(x) ww_mutex_trylock(x)
> > +#define WWT(x) ww_mutex_trylock(x, NULL)
> > #define WWL1(x) ww_mutex_lock(x, NULL)
> > #define WWU(x) ww_mutex_unlock(x)
> >
>
>
--
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v2] kernel/locking: Add context to ww_mutex_trylock.
2021-09-14 13:54 ` Daniel Vetter
@ 2021-09-16 13:00 ` Maarten Lankhorst
2021-09-16 13:28 ` Peter Zijlstra
0 siblings, 1 reply; 20+ messages in thread
From: Maarten Lankhorst @ 2021-09-16 13:00 UTC (permalink / raw)
To: Peter Zijlstra, intel-gfx, dri-devel, Ingo Molnar, Will Deacon,
Waiman Long, Boqun Feng, Liam Girdwood, Mark Brown, linux-kernel
Op 14-09-2021 om 15:54 schreef Daniel Vetter:
> On Tue, Sep 14, 2021 at 02:43:02PM +0200, Maarten Lankhorst wrote:
>> Op 14-09-2021 om 08:50 schreef Peter Zijlstra:
>>> On Mon, Sep 13, 2021 at 10:42:36AM +0200, Maarten Lankhorst wrote:
>>>
>>>>> +/**
>>>>> + * ww_mutex_trylock - tries to acquire the w/w mutex with optional acquire context
>>>>> + * @ww: mutex to lock
>>>>> + * @ww_ctx: optional w/w acquire context
>>>>> + *
>>>>> + * Trylocks a mutex with the optional acquire context; no deadlock detection is
>>>>> + * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
>>>>> + *
>>>>> + * Unlike ww_mutex_lock, no deadlock handling is performed. However, if a @ctx is
>>>>> + * specified, -EALREADY handling may happen in calls to ww_mutex_trylock.
>>>>> + *
>>>>> + * A mutex acquired with this function must be released with ww_mutex_unlock.
>>>>> + */
>>>>> +int ww_mutex_trylock(struct ww_mutex *ww, struct ww_acquire_ctx *ww_ctx)
>>>>> +{
>>>>> + if (!ww_ctx)
>>>>> + return mutex_trylock(&ww->base);
>>>>> +
>>>>> + MUTEX_WARN_ON(ww->base.magic != &ww->base);
>>>>> +
>>>>> + if (unlikely(ww_ctx == READ_ONCE(ww->ctx)))
>>>>> + return -EALREADY;
>>>> I'm not 100% sure this is a good idea, because it would make the
>>>> trylock weird. For i915 I checked manually, because I didn't want to
>>>> change the function signature. This is probably the other extreme.
>>>>
>>>> "if (ww_mutex_trylock())" would look correct, but actually be wrong
>>>> and lead to double unlock without adjustments. Maybe we could make a
>>>> ww_mutex_trylock_ctx_err, which would return -EALREADY or -EBUSY on
>>>> failure, and 0 on success? We could keep ww_mutex_trylock without
>>>> ctx, probably just #define as (!ww_mutex_trylock_ctx_err(lock, NULL))
>>> Urgh, yeah. Also, I suppose that if we already own it, we'll just fail
>>> the trylock anyway. Let me take this out.
>>>
>>>>> + /*
>>>>> + * Reset the wounded flag after a kill. No other process can
>>>>> + * race and wound us here, since they can't have a valid owner
>>>>> + * pointer if we don't have any locks held.
>>>>> + */
>>>>> + if (ww_ctx->acquired == 0)
>>>>> + ww_ctx->wounded = 0;
>>>> Yeah I guess this needs fixing too. Not completely sure since trylock
>>>> wouldn't do the whole ww dance, but since it's our first lock,
>>>> probably best to do so regardless so other users don't trip over it.
>>> This is actually critical, because if this trylock is the first lock
>>> acquisition for the context, there won't be any other opportunity to
>>> reset this value.
>>>
>>>>> +
>>>>> + if (__mutex_trylock(&ww->base)) {
>>>>> + ww_mutex_set_context_fastpath(ww, ww_ctx);
>>>>> + mutex_acquire_nest(&ww->base.dep_map, 0, 1, &ww_ctx->dep_map, _RET_IP_);
>>>>> + return 1;
>>>>> + }
>>>>> +
>>>>> + return 0;
>>>>> +}
>>>>> +EXPORT_SYMBOL(ww_mutex_trylock);
>>> Updated version below...
>>>
>>> ---
>>> Subject: kernel/locking: Add context to ww_mutex_trylock()
>>> From: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
>>> Date: Thu, 9 Sep 2021 11:32:18 +0200
>>>
>>> From: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
>>>
>>> i915 will soon gain an eviction path that trylock a whole lot of locks
>>> for eviction, getting dmesg failures like below:
>>>
>>> BUG: MAX_LOCK_DEPTH too low!
>>> turning off the locking correctness validator.
>>> depth: 48 max: 48!
>>> 48 locks held by i915_selftest/5776:
>>> #0: ffff888101a79240 (&dev->mutex){....}-{3:3}, at: __driver_attach+0x88/0x160
>>> #1: ffffc900009778c0 (reservation_ww_class_acquire){+.+.}-{0:0}, at: i915_vma_pin.constprop.63+0x39/0x1b0 [i915]
>>> #2: ffff88800cf74de8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_vma_pin.constprop.63+0x5f/0x1b0 [i915]
>>> #3: ffff88810c7f9e38 (&vm->mutex/1){+.+.}-{3:3}, at: i915_vma_pin_ww+0x1c4/0x9d0 [i915]
>>> #4: ffff88810bad5768 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
>>> #5: ffff88810bad60e8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
>>> ...
>>> #46: ffff88811964d768 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
>>> #47: ffff88811964e0e8 (reservation_ww_class_mutex){+.+.}-{3:3}, at: i915_gem_evict_something+0x110/0x860 [i915]
>>> INFO: lockdep is turned off.
>>>
>>> Fixing eviction to nest into ww_class_acquire is a high priority, but
>>> it requires a rework of the entire driver, which can only be done one
>>> step at a time.
>>>
>>> As an intermediate solution, add an acquire context to
>>> ww_mutex_trylock, which allows us to do proper nesting annotations on
>>> the trylocks, making the above lockdep splat disappear.
>>>
>>> This is also useful in regulator_lock_nested, which may avoid dropping
>>> regulator_nesting_mutex in the uncontended path, so use it there.
>>>
>>> TTM may be another user for this, where we could lock a buffer in a
>>> fastpath with list locks held, without dropping all locks we hold.
>>>
>>> [peterz: rework actual ww_mutex_trylock() implementations]
>>> Signed-off-by: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
>>> Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
>>> ---
>> My original patch series with this patch in place still passes i915 selftests, looks good to me. :)
> For merge logistics, can we pls have a stable branch? I expect that the
> i915 patches will be ready for 5.16.
>
> Or send it in for -rc2 so that the interface change doesn't cause needless
> conflicts, whatever you think is best.
> -Daniel
Yeah, some central branch drm could pull from, would make upstreaming patches that depends on it easier. :)
^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v2] kernel/locking: Add context to ww_mutex_trylock.
2021-09-16 13:00 ` Maarten Lankhorst
@ 2021-09-16 13:28 ` Peter Zijlstra
2021-09-17 13:13 ` Peter Zijlstra
0 siblings, 1 reply; 20+ messages in thread
From: Peter Zijlstra @ 2021-09-16 13:28 UTC (permalink / raw)
To: Maarten Lankhorst
Cc: intel-gfx, dri-devel, Ingo Molnar, Will Deacon, Waiman Long,
Boqun Feng, Liam Girdwood, Mark Brown, linux-kernel
On Thu, Sep 16, 2021 at 03:00:39PM +0200, Maarten Lankhorst wrote:
> > For merge logistics, can we pls have a stable branch? I expect that the
> > i915 patches will be ready for 5.16.
> >
> > Or send it in for -rc2 so that the interface change doesn't cause needless
> > conflicts, whatever you think is best.
> Yeah, some central branch drm could pull from, would make upstreaming patches that depends on it easier. :)
I think I'll make tip/locking/wwmutex and include that in
tip/locking/core, let me have a poke.
^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v2] kernel/locking: Add context to ww_mutex_trylock.
2021-09-16 13:28 ` Peter Zijlstra
@ 2021-09-17 13:13 ` Peter Zijlstra
2021-09-20 15:02 ` Joonas Lahtinen
0 siblings, 1 reply; 20+ messages in thread
From: Peter Zijlstra @ 2021-09-17 13:13 UTC (permalink / raw)
To: Maarten Lankhorst
Cc: intel-gfx, dri-devel, Ingo Molnar, Will Deacon, Waiman Long,
Boqun Feng, Liam Girdwood, Mark Brown, linux-kernel
On Thu, Sep 16, 2021 at 03:28:11PM +0200, Peter Zijlstra wrote:
> On Thu, Sep 16, 2021 at 03:00:39PM +0200, Maarten Lankhorst wrote:
>
> > > For merge logistics, can we pls have a stable branch? I expect that the
> > > i915 patches will be ready for 5.16.
> > >
> > > Or send it in for -rc2 so that the interface change doesn't cause needless
> > > conflicts, whatever you think is best.
>
> > Yeah, some central branch drm could pull from, would make upstreaming patches that depends on it easier. :)
>
> I think I'll make tip/locking/wwmutex and include that in
> tip/locking/core, let me have a poke.
This is now so. Enjoy!
^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v2] kernel/locking: Add context to ww_mutex_trylock.
2021-09-17 13:13 ` Peter Zijlstra
@ 2021-09-20 15:02 ` Joonas Lahtinen
0 siblings, 0 replies; 20+ messages in thread
From: Joonas Lahtinen @ 2021-09-20 15:02 UTC (permalink / raw)
To: Maarten Lankhorst, Peter Zijlstra
Cc: intel-gfx, dri-devel, Ingo Molnar, Will Deacon, Waiman Long,
Boqun Feng, Liam Girdwood, Mark Brown, linux-kernel
Quoting Peter Zijlstra (2021-09-17 16:13:19)
> On Thu, Sep 16, 2021 at 03:28:11PM +0200, Peter Zijlstra wrote:
> > On Thu, Sep 16, 2021 at 03:00:39PM +0200, Maarten Lankhorst wrote:
> >
> > > > For merge logistics, can we pls have a stable branch? I expect that the
> > > > i915 patches will be ready for 5.16.
> > > >
> > > > Or send it in for -rc2 so that the interface change doesn't cause needless
> > > > conflicts, whatever you think is best.
> >
> > > Yeah, some central branch drm could pull from, would make upstreaming patches that depends on it easier. :)
> >
> > I think I'll make tip/locking/wwmutex and include that in
> > tip/locking/core, let me have a poke.
>
> This is now so. Enjoy!
This is now merged to drm-intel-gt-next.
Regards, Joonas
^ permalink raw reply [flat|nested] 20+ messages in thread
* [PATCH] kernel/locking: Use a pointer in ww_mutex_trylock().
2021-09-14 6:50 ` Peter Zijlstra
2021-09-14 12:43 ` Maarten Lankhorst
@ 2021-11-04 12:27 ` Sebastian Andrzej Siewior
1 sibling, 0 replies; 20+ messages in thread
From: Sebastian Andrzej Siewior @ 2021-11-04 12:27 UTC (permalink / raw)
To: Peter Zijlstra
Cc: Daniel Vetter, intel-gfx, Liam Girdwood, dri-devel, linux-kernel,
Ingo Molnar, Mark Brown, Waiman Long, Thomas Gleixner,
Will Deacon, Boqun Feng
mutex_acquire_nest() expects a pointer, pass the pointer.
Fixes: 12235da8c80a1 ("kernel/locking: Add context to ww_mutex_trylock()")
Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
---
Not sure why I haven't seen this earlier…
kernel/locking/ww_rt_mutex.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/kernel/locking/ww_rt_mutex.c b/kernel/locking/ww_rt_mutex.c
index 0e00205cf467a..d1473c624105c 100644
--- a/kernel/locking/ww_rt_mutex.c
+++ b/kernel/locking/ww_rt_mutex.c
@@ -26,7 +26,7 @@ int ww_mutex_trylock(struct ww_mutex *lock, struct ww_acquire_ctx *ww_ctx)
if (__rt_mutex_trylock(&rtm->rtmutex)) {
ww_mutex_set_context_fastpath(lock, ww_ctx);
- mutex_acquire_nest(&rtm->dep_map, 0, 1, ww_ctx->dep_map, _RET_IP_);
+ mutex_acquire_nest(&rtm->dep_map, 0, 1, &ww_ctx->dep_map, _RET_IP_);
return 1;
}
--
2.33.1
^ permalink raw reply related [flat|nested] 20+ messages in thread
* Re: [PATCH] kernel/locking: Add context to ww_mutex_trylock.
[not found] <202109091811.OVelmBhx-lkp@intel.com>
@ 2021-09-14 3:49 ` kernel test robot
0 siblings, 0 replies; 20+ messages in thread
From: kernel test robot @ 2021-09-14 3:49 UTC (permalink / raw)
To: Maarten Lankhorst, intel-gfx
Cc: llvm, kbuild-all, dri-devel, Maarten Lankhorst, Peter Zijlstra,
Ingo Molnar, Will Deacon, Waiman Long, Boqun Feng, Liam Girdwood,
Mark Brown
[-- Attachment #1: Type: text/plain, Size: 7281 bytes --]
Hi Maarten,
I love your patch! Perhaps something to improve:
[auto build test WARNING on regulator/for-next]
[also build test WARNING on tegra-drm/drm/tegra/for-next v5.14]
[cannot apply to tip/locking/core linus/master next-20210909]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Maarten-Lankhorst/kernel-locking-Add-context-to-ww_mutex_trylock/20210907-212220
base: https://git.kernel.org/pub/scm/linux/kernel/git/broonie/regulator.git for-next
:::::: branch date: 2 days ago
:::::: commit date: 2 days ago
config: x86_64-randconfig-c007-20210908 (attached as .config)
compiler: clang version 14.0.0 (https://github.com/llvm/llvm-project 9c476172b93367d2cb88d7d3f4b1b5b456fa6020)
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# https://github.com/0day-ci/linux/commit/1e66afa09b0aa7d6db3122f0312e10d36f6fa217
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Maarten-Lankhorst/kernel-locking-Add-context-to-ww_mutex_trylock/20210907-212220
git checkout 1e66afa09b0aa7d6db3122f0312e10d36f6fa217
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=x86_64 clang-analyzer
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>
clang-analyzer warnings: (new ones prefixed by >>)
>> kernel/locking/test-ww_mutex.c:172:2: warning: Undefined or garbage value returned to caller [clang-analyzer-core.uninitialized.UndefReturn]
return ret;
^
kernel/locking/test-ww_mutex.c:639:8: note: Calling 'test_aa'
ret = test_aa(true);
^~~~~~~~~~~~~
kernel/locking/test-ww_mutex.c:125:2: note: 'ret' declared without an initial value
int ret;
^~~~~~~
kernel/locking/test-ww_mutex.c:126:21: note: 'trylock' is true
const char *from = trylock ? "trylock" : "lock";
^~~~~~~
kernel/locking/test-ww_mutex.c:126:21: note: '?' condition is true
kernel/locking/test-ww_mutex.c:131:7: note: 'trylock' is true
if (!trylock) {
^~~~~~~
kernel/locking/test-ww_mutex.c:131:2: note: Taking false branch
if (!trylock) {
^
kernel/locking/test-ww_mutex.c:138:7: note: Assuming the condition is true
if (!ww_mutex_trylock(&mutex, &ctx)) {
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
kernel/locking/test-ww_mutex.c:138:3: note: Taking true branch
if (!ww_mutex_trylock(&mutex, &ctx)) {
^
kernel/locking/test-ww_mutex.c:140:4: note: Control jumps to line 171
goto out;
^
kernel/locking/test-ww_mutex.c:172:2: note: Undefined or garbage value returned to caller
return ret;
^ ~~~
vim +172 kernel/locking/test-ww_mutex.c
f2a5fec17395f2 Chris Wilson 2016-12-01 120
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 121 static int test_aa(bool trylock)
c22fb3807fd0a3 Chris Wilson 2016-12-01 122 {
c22fb3807fd0a3 Chris Wilson 2016-12-01 123 struct ww_mutex mutex;
c22fb3807fd0a3 Chris Wilson 2016-12-01 124 struct ww_acquire_ctx ctx;
c22fb3807fd0a3 Chris Wilson 2016-12-01 125 int ret;
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 126 const char *from = trylock ? "trylock" : "lock";
c22fb3807fd0a3 Chris Wilson 2016-12-01 127
c22fb3807fd0a3 Chris Wilson 2016-12-01 128 ww_mutex_init(&mutex, &ww_class);
c22fb3807fd0a3 Chris Wilson 2016-12-01 129 ww_acquire_init(&ctx, &ww_class);
c22fb3807fd0a3 Chris Wilson 2016-12-01 130
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 131 if (!trylock) {
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 132 ret = ww_mutex_lock(&mutex, &ctx);
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 133 if (ret) {
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 134 pr_err("%s: initial lock failed!\n", __func__);
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 135 goto out;
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 136 }
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 137 } else {
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 138 if (!ww_mutex_trylock(&mutex, &ctx)) {
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 139 pr_err("%s: initial trylock failed!\n", __func__);
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 140 goto out;
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 141 }
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 142 }
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 143
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 144 if (ww_mutex_trylock(&mutex, NULL)) {
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 145 pr_err("%s: trylocked itself without context from %s!\n", __func__, from);
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 146 ww_mutex_unlock(&mutex);
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 147 ret = -EINVAL;
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 148 goto out;
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 149 }
c22fb3807fd0a3 Chris Wilson 2016-12-01 150
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 151 if (ww_mutex_trylock(&mutex, &ctx)) {
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 152 pr_err("%s: trylocked itself with context from %s!\n", __func__, from);
c22fb3807fd0a3 Chris Wilson 2016-12-01 153 ww_mutex_unlock(&mutex);
c22fb3807fd0a3 Chris Wilson 2016-12-01 154 ret = -EINVAL;
c22fb3807fd0a3 Chris Wilson 2016-12-01 155 goto out;
c22fb3807fd0a3 Chris Wilson 2016-12-01 156 }
c22fb3807fd0a3 Chris Wilson 2016-12-01 157
c22fb3807fd0a3 Chris Wilson 2016-12-01 158 ret = ww_mutex_lock(&mutex, &ctx);
c22fb3807fd0a3 Chris Wilson 2016-12-01 159 if (ret != -EALREADY) {
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 160 pr_err("%s: missed deadlock for recursing, ret=%d from %s\n",
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 161 __func__, ret, from);
c22fb3807fd0a3 Chris Wilson 2016-12-01 162 if (!ret)
c22fb3807fd0a3 Chris Wilson 2016-12-01 163 ww_mutex_unlock(&mutex);
c22fb3807fd0a3 Chris Wilson 2016-12-01 164 ret = -EINVAL;
c22fb3807fd0a3 Chris Wilson 2016-12-01 165 goto out;
c22fb3807fd0a3 Chris Wilson 2016-12-01 166 }
c22fb3807fd0a3 Chris Wilson 2016-12-01 167
1e66afa09b0aa7 Maarten Lankhorst 2021-09-07 168 ww_mutex_unlock(&mutex);
c22fb3807fd0a3 Chris Wilson 2016-12-01 169 ret = 0;
c22fb3807fd0a3 Chris Wilson 2016-12-01 170 out:
c22fb3807fd0a3 Chris Wilson 2016-12-01 171 ww_acquire_fini(&ctx);
c22fb3807fd0a3 Chris Wilson 2016-12-01 @172 return ret;
c22fb3807fd0a3 Chris Wilson 2016-12-01 173 }
c22fb3807fd0a3 Chris Wilson 2016-12-01 174
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org
[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 30263 bytes --]
[-- Attachment #3: Attached Message Part --]
[-- Type: text/plain, Size: 154 bytes --]
_______________________________________________
kbuild mailing list -- kbuild@lists.01.org
To unsubscribe send an email to kbuild-leave@lists.01.org
^ permalink raw reply [flat|nested] 20+ messages in thread
end of thread, other threads:[~2021-11-04 12:27 UTC | newest]
Thread overview: 20+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-09-07 13:20 [PATCH] kernel/locking: Add context to ww_mutex_trylock Maarten Lankhorst
2021-09-07 14:59 ` kernel test robot
2021-09-08 10:14 ` Peter Zijlstra
2021-09-08 18:30 ` Daniel Vetter
2021-09-09 5:38 ` Maarten Lankhorst
2021-09-09 8:22 ` Peter Zijlstra
2021-09-09 9:32 ` [PATCH v2] " Maarten Lankhorst
2021-09-10 15:02 ` Peter Zijlstra
2021-09-10 17:27 ` Peter Zijlstra
2021-09-13 8:42 ` Maarten Lankhorst
2021-09-14 6:50 ` Peter Zijlstra
2021-09-14 12:43 ` Maarten Lankhorst
2021-09-14 13:54 ` Daniel Vetter
2021-09-16 13:00 ` Maarten Lankhorst
2021-09-16 13:28 ` Peter Zijlstra
2021-09-17 13:13 ` Peter Zijlstra
2021-09-20 15:02 ` Joonas Lahtinen
2021-11-04 12:27 ` [PATCH] kernel/locking: Use a pointer in ww_mutex_trylock() Sebastian Andrzej Siewior
2021-09-10 18:06 ` [PATCH v2] kernel/locking: Add context to ww_mutex_trylock Mark Brown
[not found] <202109091811.OVelmBhx-lkp@intel.com>
2021-09-14 3:49 ` [PATCH] " kernel test robot
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).