mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-24 01:41:39 +00:00
![Chris Wilson](/assets/img/avatar_default.png)
If the backend wishes to defer the wakeref parking, make it responsible for unlocking the wakeref (i.e. bumping the counter). This allows it to time the unlock much more carefully in case it happens to needs the wakeref to be active during its deferral. For instance, during engine parking we may choose to emit an idle barrier (a request). To do so, we borrow the engine->kernel_context timeline and to ensure exclusive access we keep the engine->wakeref.count as 0. However, to submit that request to HW may require a intel_engine_pm_get() (e.g. to keep the submission tasklet alive) and before we allow that we have to rewake our wakeref to avoid a recursive deadlock. <4> [257.742916] IRQs not enabled as expected <4> [257.742930] WARNING: CPU: 0 PID: 0 at kernel/softirq.c:169 __local_bh_enable_ip+0xa9/0x100 <4> [257.742936] Modules linked in: vgem snd_hda_codec_hdmi snd_hda_codec_realtek snd_hda_codec_generic i915 btusb btrtl btbcm btintel snd_hda_intel snd_intel_nhlt bluetooth snd_hda_codec coretemp snd_hwdep crct10dif_pclmul snd_hda_core crc32_pclmul ecdh_generic ecc ghash_clmulni_intel snd_pcm r8169 realtek lpc_ich prime_numbers i2c_hid <4> [257.742991] CPU: 0 PID: 0 Comm: swapper/0 Tainted: G U W 5.3.0-rc3-g5d0a06cd532c-drmtip_340+ #1 <4> [257.742998] Hardware name: GIGABYTE GB-BXBT-1900/MZBAYAB-00, BIOS F6 02/17/2015 <4> [257.743008] RIP: 0010:__local_bh_enable_ip+0xa9/0x100 <4> [257.743017] Code: 37 5b 5d c3 8b 80 50 08 00 00 85 c0 75 a9 80 3d 0b be 25 01 00 75 a0 48 c7 c7 f3 0c 06 ac c6 05 fb bd 25 01 01 e8 77 84 ff ff <0f> 0b eb 89 48 89 ef e8 3b 41 06 00 eb 98 e8 e4 5c f4 ff 5b 5d c3 <4> [257.743025] RSP: 0018:ffffa78600003cb8 EFLAGS: 00010086 <4> [257.743035] RAX: 0000000000000000 RBX: 0000000000000200 RCX: 0000000000010302 <4> [257.743042] RDX: 0000000080010302 RSI: 0000000000000000 RDI: 00000000ffffffff <4> [257.743050] RBP: ffffffffc0494bb3 R08: 0000000000000000 R09: 0000000000000001 <4> [257.743058] R10: 0000000014c8f0e9 R11: 00000000fee2ff8e R12: ffffa23ba8c38008 <4> [257.743065] R13: ffffa23bacc579c0 R14: ffffa23bb7db0f60 R15: ffffa23b9cc8c430 <4> [257.743074] FS: 0000000000000000(0000) GS:ffffa23bbba00000(0000) knlGS:0000000000000000 <4> [257.743082] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 <4> [257.743089] CR2: 00007fe477b20778 CR3: 000000011f72a000 CR4: 00000000001006f0 <4> [257.743096] Call Trace: <4> [257.743104] <IRQ> <4> [257.743265] __i915_request_commit+0x240/0x5d0 [i915] <4> [257.743427] ? __i915_request_create+0x228/0x4c0 [i915] <4> [257.743584] __engine_park+0x64/0x250 [i915] <4> [257.743730] ____intel_wakeref_put_last+0x1c/0x70 [i915] <4> [257.743878] i915_sample+0x2ee/0x310 [i915] <4> [257.744030] ? i915_pmu_cpu_offline+0xb0/0xb0 [i915] <4> [257.744040] __hrtimer_run_queues+0x11e/0x4b0 <4> [257.744068] hrtimer_interrupt+0xea/0x250 <4> [257.744079] ? lockdep_hardirqs_off+0x79/0xd0 <4> [257.744101] smp_apic_timer_interrupt+0x96/0x280 <4> [257.744114] apic_timer_interrupt+0xf/0x20 <4> [257.744125] RIP: 0010:__do_softirq+0xb3/0x4ae v2: Keep the priority_hint assert v3: That assert was desperately trying to point out my bug. Sorry, little assert. Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=111378 Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com> Cc: Mika Kuoppala <mika.kuoppala@linux.intel.com> Reviewed-by: Mika Kuoppala <mika.kuoppala@linux.intel.com> Link: https://patchwork.freedesktop.org/patch/msgid/20190813190705.23869-1-chris@chris-wilson.co.uk
219 lines
5.7 KiB
C
219 lines
5.7 KiB
C
/*
|
|
* SPDX-License-Identifier: MIT
|
|
*
|
|
* Copyright © 2019 Intel Corporation
|
|
*/
|
|
|
|
#ifndef INTEL_WAKEREF_H
|
|
#define INTEL_WAKEREF_H
|
|
|
|
#include <linux/atomic.h>
|
|
#include <linux/bits.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/refcount.h>
|
|
#include <linux/stackdepot.h>
|
|
#include <linux/timer.h>
|
|
#include <linux/workqueue.h>
|
|
|
|
#if IS_ENABLED(CONFIG_DRM_I915_DEBUG)
|
|
#define INTEL_WAKEREF_BUG_ON(expr) BUG_ON(expr)
|
|
#else
|
|
#define INTEL_WAKEREF_BUG_ON(expr) BUILD_BUG_ON_INVALID(expr)
|
|
#endif
|
|
|
|
struct intel_runtime_pm;
|
|
struct intel_wakeref;
|
|
|
|
typedef depot_stack_handle_t intel_wakeref_t;
|
|
|
|
struct intel_wakeref_ops {
|
|
int (*get)(struct intel_wakeref *wf);
|
|
int (*put)(struct intel_wakeref *wf);
|
|
|
|
unsigned long flags;
|
|
#define INTEL_WAKEREF_PUT_ASYNC BIT(0)
|
|
};
|
|
|
|
struct intel_wakeref {
|
|
atomic_t count;
|
|
struct mutex mutex;
|
|
|
|
intel_wakeref_t wakeref;
|
|
|
|
struct intel_runtime_pm *rpm;
|
|
const struct intel_wakeref_ops *ops;
|
|
|
|
struct work_struct work;
|
|
};
|
|
|
|
void __intel_wakeref_init(struct intel_wakeref *wf,
|
|
struct intel_runtime_pm *rpm,
|
|
const struct intel_wakeref_ops *ops,
|
|
struct lock_class_key *key);
|
|
#define intel_wakeref_init(wf, rpm, ops) do { \
|
|
static struct lock_class_key __key; \
|
|
\
|
|
__intel_wakeref_init((wf), (rpm), (ops), &__key); \
|
|
} while (0)
|
|
|
|
int __intel_wakeref_get_first(struct intel_wakeref *wf);
|
|
void __intel_wakeref_put_last(struct intel_wakeref *wf);
|
|
|
|
/**
|
|
* intel_wakeref_get: Acquire the wakeref
|
|
* @i915: the drm_i915_private device
|
|
* @wf: the wakeref
|
|
* @fn: callback for acquired the wakeref, called only on first acquire.
|
|
*
|
|
* Acquire a hold on the wakeref. The first user to do so, will acquire
|
|
* the runtime pm wakeref and then call the @fn underneath the wakeref
|
|
* mutex.
|
|
*
|
|
* Note that @fn is allowed to fail, in which case the runtime-pm wakeref
|
|
* will be released and the acquisition unwound, and an error reported.
|
|
*
|
|
* Returns: 0 if the wakeref was acquired successfully, or a negative error
|
|
* code otherwise.
|
|
*/
|
|
static inline int
|
|
intel_wakeref_get(struct intel_wakeref *wf)
|
|
{
|
|
if (unlikely(!atomic_inc_not_zero(&wf->count)))
|
|
return __intel_wakeref_get_first(wf);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* intel_wakeref_get_if_in_use: Acquire the wakeref
|
|
* @wf: the wakeref
|
|
*
|
|
* Acquire a hold on the wakeref, but only if the wakeref is already
|
|
* active.
|
|
*
|
|
* Returns: true if the wakeref was acquired, false otherwise.
|
|
*/
|
|
static inline bool
|
|
intel_wakeref_get_if_active(struct intel_wakeref *wf)
|
|
{
|
|
return atomic_inc_not_zero(&wf->count);
|
|
}
|
|
|
|
/**
|
|
* intel_wakeref_put: Release the wakeref
|
|
* @i915: the drm_i915_private device
|
|
* @wf: the wakeref
|
|
* @fn: callback for releasing the wakeref, called only on final release.
|
|
*
|
|
* Release our hold on the wakeref. When there are no more users,
|
|
* the runtime pm wakeref will be released after the @fn callback is called
|
|
* underneath the wakeref mutex.
|
|
*
|
|
* Note that @fn is allowed to fail, in which case the runtime-pm wakeref
|
|
* is retained and an error reported.
|
|
*
|
|
* Returns: 0 if the wakeref was released successfully, or a negative error
|
|
* code otherwise.
|
|
*/
|
|
static inline void
|
|
intel_wakeref_put(struct intel_wakeref *wf)
|
|
{
|
|
INTEL_WAKEREF_BUG_ON(atomic_read(&wf->count) <= 0);
|
|
if (unlikely(!atomic_add_unless(&wf->count, -1, 1)))
|
|
__intel_wakeref_put_last(wf);
|
|
}
|
|
|
|
/**
|
|
* intel_wakeref_lock: Lock the wakeref (mutex)
|
|
* @wf: the wakeref
|
|
*
|
|
* Locks the wakeref to prevent it being acquired or released. New users
|
|
* can still adjust the counter, but the wakeref itself (and callback)
|
|
* cannot be acquired or released.
|
|
*/
|
|
static inline void
|
|
intel_wakeref_lock(struct intel_wakeref *wf)
|
|
__acquires(wf->mutex)
|
|
{
|
|
mutex_lock(&wf->mutex);
|
|
}
|
|
|
|
/**
|
|
* intel_wakeref_unlock: Unlock the wakeref
|
|
* @wf: the wakeref
|
|
*
|
|
* Releases a previously acquired intel_wakeref_lock().
|
|
*/
|
|
static inline void
|
|
intel_wakeref_unlock(struct intel_wakeref *wf)
|
|
__releases(wf->mutex)
|
|
{
|
|
mutex_unlock(&wf->mutex);
|
|
}
|
|
|
|
/**
|
|
* intel_wakeref_is_active: Query whether the wakeref is currently held
|
|
* @wf: the wakeref
|
|
*
|
|
* Returns: true if the wakeref is currently held.
|
|
*/
|
|
static inline bool
|
|
intel_wakeref_is_active(const struct intel_wakeref *wf)
|
|
{
|
|
return READ_ONCE(wf->wakeref);
|
|
}
|
|
|
|
/**
|
|
* __intel_wakeref_defer_park: Defer the current park callback
|
|
* @wf: the wakeref
|
|
*/
|
|
static inline void
|
|
__intel_wakeref_defer_park(struct intel_wakeref *wf)
|
|
{
|
|
INTEL_WAKEREF_BUG_ON(atomic_read(&wf->count));
|
|
atomic_set_release(&wf->count, 1);
|
|
}
|
|
|
|
/**
|
|
* intel_wakeref_wait_for_idle: Wait until the wakeref is idle
|
|
* @wf: the wakeref
|
|
*
|
|
* Wait for the earlier asynchronous release of the wakeref. Note
|
|
* this will wait for any third party as well, so make sure you only wait
|
|
* when you have control over the wakeref and trust no one else is acquiring
|
|
* it.
|
|
*
|
|
* Return: 0 on success, error code if killed.
|
|
*/
|
|
int intel_wakeref_wait_for_idle(struct intel_wakeref *wf);
|
|
|
|
struct intel_wakeref_auto {
|
|
struct intel_runtime_pm *rpm;
|
|
struct timer_list timer;
|
|
intel_wakeref_t wakeref;
|
|
spinlock_t lock;
|
|
refcount_t count;
|
|
};
|
|
|
|
/**
|
|
* intel_wakeref_auto: Delay the runtime-pm autosuspend
|
|
* @wf: the wakeref
|
|
* @timeout: relative timeout in jiffies
|
|
*
|
|
* The runtime-pm core uses a suspend delay after the last wakeref
|
|
* is released before triggering runtime suspend of the device. That
|
|
* delay is configurable via sysfs with little regard to the device
|
|
* characteristics. Instead, we want to tune the autosuspend based on our
|
|
* HW knowledge. intel_wakeref_auto() delays the sleep by the supplied
|
|
* timeout.
|
|
*
|
|
* Pass @timeout = 0 to cancel a previous autosuspend by executing the
|
|
* suspend immediately.
|
|
*/
|
|
void intel_wakeref_auto(struct intel_wakeref_auto *wf, unsigned long timeout);
|
|
|
|
void intel_wakeref_auto_init(struct intel_wakeref_auto *wf,
|
|
struct intel_runtime_pm *rpm);
|
|
void intel_wakeref_auto_fini(struct intel_wakeref_auto *wf);
|
|
|
|
#endif /* INTEL_WAKEREF_H */
|