mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 03:10:12 +00:00
![Vlastimil Babka](/assets/img/avatar_default.png)
Currently, enabling CONFIG_STACKDEPOT means its stack_table will be allocated from memblock, even if stack depot ends up not actually used. The default size of stack_table is 4MB on 32-bit, 8MB on 64-bit. This is fine for use-cases such as KASAN which is also a config option and has overhead on its own. But it's an issue for functionality that has to be actually enabled on boot (page_owner) or depends on hardware (GPU drivers) and thus the memory might be wasted. This was raised as an issue [1] when attempting to add stackdepot support for SLUB's debug object tracking functionality. It's common to build kernels with CONFIG_SLUB_DEBUG and enable slub_debug on boot only when needed, or create only specific kmem caches with debugging for testing purposes. It would thus be more efficient if stackdepot's table was allocated only when actually going to be used. This patch thus makes the allocation (and whole stack_depot_init() call) optional: - Add a CONFIG_STACKDEPOT_ALWAYS_INIT flag to keep using the current well-defined point of allocation as part of mem_init(). Make CONFIG_KASAN select this flag. - Other users have to call stack_depot_init() as part of their own init when it's determined that stack depot will actually be used. This may depend on both config and runtime conditions. Convert current users which are page_owner and several in the DRM subsystem. Same will be done for SLUB later. - Because the init might now be called after the boot-time memblock allocation has given all memory to the buddy allocator, change stack_depot_init() to allocate stack_table with kvmalloc() when memblock is no longer available. Also handle allocation failure by disabling stackdepot (could have theoretically happened even with memblock allocation previously), and don't unnecessarily align the memblock allocation to its own size anymore. [1] https://lore.kernel.org/all/CAMuHMdW=eoVzM1Re5FVoEN87nKfiLmM2+Ah7eNu2KXEhCvbZyA@mail.gmail.com/ Link: https://lkml.kernel.org/r/20211013073005.11351-1-vbabka@suse.cz Signed-off-by: Vlastimil Babka <vbabka@suse.cz> Acked-by: Dmitry Vyukov <dvyukov@google.com> Reviewed-by: Marco Elver <elver@google.com> # stackdepot Cc: Marco Elver <elver@google.com> Cc: Vijayanand Jitta <vjitta@codeaurora.org> Cc: Maarten Lankhorst <maarten.lankhorst@linux.intel.com> Cc: Maxime Ripard <mripard@kernel.org> Cc: Thomas Zimmermann <tzimmermann@suse.de> Cc: David Airlie <airlied@linux.ie> Cc: Daniel Vetter <daniel@ffwll.ch> Cc: Andrey Ryabinin <ryabinin.a.a@gmail.com> Cc: Alexander Potapenko <glider@google.com> Cc: Andrey Konovalov <andreyknvl@gmail.com> Cc: Dmitry Vyukov <dvyukov@google.com> Cc: Geert Uytterhoeven <geert@linux-m68k.org> Cc: Oliver Glitta <glittao@gmail.com> Cc: Imran Khan <imran.f.khan@oracle.com> From: Colin Ian King <colin.king@canonical.com> Subject: lib/stackdepot: fix spelling mistake and grammar in pr_err message There is a spelling mistake of the work allocation so fix this and re-phrase the message to make it easier to read. Link: https://lkml.kernel.org/r/20211015104159.11282-1-colin.king@canonical.com Signed-off-by: Colin Ian King <colin.king@canonical.com> Cc: Vlastimil Babka <vbabka@suse.cz> From: Vlastimil Babka <vbabka@suse.cz> Subject: lib/stackdepot: allow optional init and stack_table allocation by kvmalloc() - fixup On FLATMEM, we call page_ext_init_flatmem_late() just before kmem_cache_init() which means stack_depot_init() (called by page owner init) will not recognize properly it should use kvmalloc() and not memblock_alloc(). memblock_alloc() will also not issue a warning and return a block memory that can be invalid and cause kernel page fault when saving stacks, as reported by the kernel test robot [1]. Fix this by moving page_ext_init_flatmem_late() below kmem_cache_init() so that slab_is_available() is true during stack_depot_init(). SPARSEMEM doesn't have this issue, as it doesn't do page_ext_init_flatmem_late(), but a different page_ext_init() even later in the boot process. Thanks to Mike Rapoport for pointing out the FLATMEM init ordering issue. While at it, also actually resolve a checkpatch warning in stack_depot_init() from DRM CI, which was supposed to be in the original patch already. [1] https://lore.kernel.org/all/20211014085450.GC18719@xsang-OptiPlex-9020/ Link: https://lkml.kernel.org/r/6abd9213-19a9-6d58-cedc-2414386d2d81@suse.cz Signed-off-by: Vlastimil Babka <vbabka@suse.cz> Reported-by: kernel test robot <oliver.sang@intel.com> Cc: Mike Rapoport <rppt@kernel.org> Cc: Stephen Rothwell <sfr@canb.auug.org.au> From: Vlastimil Babka <vbabka@suse.cz> Subject: lib/stackdepot: allow optional init and stack_table allocation by kvmalloc() - fixup3 Due tocd06ab2fd4
("drm/locking: add backtrace for locking contended locks without backoff") landing recently to -next adding a new stack depot user in drivers/gpu/drm/drm_modeset_lock.c we need to add an appropriate call to stack_depot_init() there as well. Link: https://lkml.kernel.org/r/2a692365-cfa1-64f2-34e0-8aa5674dce5e@suse.cz Signed-off-by: Vlastimil Babka <vbabka@suse.cz> Cc: Jani Nikula <jani.nikula@intel.com> Cc: Naresh Kamboju <naresh.kamboju@linaro.org> Cc: Marco Elver <elver@google.com> Cc: Vijayanand Jitta <vjitta@codeaurora.org> Cc: Maarten Lankhorst <maarten.lankhorst@linux.intel.com> Cc: Maxime Ripard <mripard@kernel.org> Cc: Thomas Zimmermann <tzimmermann@suse.de> Cc: David Airlie <airlied@linux.ie> Cc: Daniel Vetter <daniel@ffwll.ch> Cc: Andrey Ryabinin <ryabinin.a.a@gmail.com> Cc: Alexander Potapenko <glider@google.com> Cc: Andrey Konovalov <andreyknvl@gmail.com> Cc: Dmitry Vyukov <dvyukov@google.com> Cc: Geert Uytterhoeven <geert@linux-m68k.org> Cc: Oliver Glitta <glittao@gmail.com> Cc: Imran Khan <imran.f.khan@oracle.com> Cc: Stephen Rothwell <sfr@canb.auug.org.au> From: Vlastimil Babka <vbabka@suse.cz> Subject: lib/stackdepot: allow optional init and stack_table allocation by kvmalloc() - fixup4 Due to4e66934eaa
("lib: add reference counting tracking infrastructure") landing recently to net-next adding a new stack depot user in lib/ref_tracker.c we need to add an appropriate call to stack_depot_init() there as well. Link: https://lkml.kernel.org/r/45c1b738-1a2f-5b5f-2f6d-86fab206d01c@suse.cz Signed-off-by: Vlastimil Babka <vbabka@suse.cz> Reviewed-by: Eric Dumazet <edumazet@google.com> Cc: Jiri Slab <jirislaby@gmail.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
481 lines
14 KiB
C
481 lines
14 KiB
C
/*
|
|
* Copyright (C) 2014 Red Hat
|
|
* Author: Rob Clark <robdclark@gmail.com>
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
#include <drm/drm_atomic.h>
|
|
#include <drm/drm_crtc.h>
|
|
#include <drm/drm_device.h>
|
|
#include <drm/drm_modeset_lock.h>
|
|
#include <drm/drm_print.h>
|
|
|
|
/**
|
|
* DOC: kms locking
|
|
*
|
|
* As KMS moves toward more fine grained locking, and atomic ioctl where
|
|
* userspace can indirectly control locking order, it becomes necessary
|
|
* to use &ww_mutex and acquire-contexts to avoid deadlocks. But because
|
|
* the locking is more distributed around the driver code, we want a bit
|
|
* of extra utility/tracking out of our acquire-ctx. This is provided
|
|
* by &struct drm_modeset_lock and &struct drm_modeset_acquire_ctx.
|
|
*
|
|
* For basic principles of &ww_mutex, see: Documentation/locking/ww-mutex-design.rst
|
|
*
|
|
* The basic usage pattern is to::
|
|
*
|
|
* drm_modeset_acquire_init(ctx, DRM_MODESET_ACQUIRE_INTERRUPTIBLE)
|
|
* retry:
|
|
* foreach (lock in random_ordered_set_of_locks) {
|
|
* ret = drm_modeset_lock(lock, ctx)
|
|
* if (ret == -EDEADLK) {
|
|
* ret = drm_modeset_backoff(ctx);
|
|
* if (!ret)
|
|
* goto retry;
|
|
* }
|
|
* if (ret)
|
|
* goto out;
|
|
* }
|
|
* ... do stuff ...
|
|
* out:
|
|
* drm_modeset_drop_locks(ctx);
|
|
* drm_modeset_acquire_fini(ctx);
|
|
*
|
|
* For convenience this control flow is implemented in
|
|
* DRM_MODESET_LOCK_ALL_BEGIN() and DRM_MODESET_LOCK_ALL_END() for the case
|
|
* where all modeset locks need to be taken through drm_modeset_lock_all_ctx().
|
|
*
|
|
* If all that is needed is a single modeset lock, then the &struct
|
|
* drm_modeset_acquire_ctx is not needed and the locking can be simplified
|
|
* by passing a NULL instead of ctx in the drm_modeset_lock() call or
|
|
* calling drm_modeset_lock_single_interruptible(). To unlock afterwards
|
|
* call drm_modeset_unlock().
|
|
*
|
|
* On top of these per-object locks using &ww_mutex there's also an overall
|
|
* &drm_mode_config.mutex, for protecting everything else. Mostly this means
|
|
* probe state of connectors, and preventing hotplug add/removal of connectors.
|
|
*
|
|
* Finally there's a bunch of dedicated locks to protect drm core internal
|
|
* lists and lookup data structures.
|
|
*/
|
|
|
|
static DEFINE_WW_CLASS(crtc_ww_class);
|
|
|
|
#if IS_ENABLED(CONFIG_DRM_DEBUG_MODESET_LOCK)
|
|
static noinline depot_stack_handle_t __drm_stack_depot_save(void)
|
|
{
|
|
unsigned long entries[8];
|
|
unsigned int n;
|
|
|
|
n = stack_trace_save(entries, ARRAY_SIZE(entries), 1);
|
|
|
|
return stack_depot_save(entries, n, GFP_NOWAIT | __GFP_NOWARN);
|
|
}
|
|
|
|
static void __drm_stack_depot_print(depot_stack_handle_t stack_depot)
|
|
{
|
|
struct drm_printer p = drm_debug_printer("drm_modeset_lock");
|
|
unsigned long *entries;
|
|
unsigned int nr_entries;
|
|
char *buf;
|
|
|
|
buf = kmalloc(PAGE_SIZE, GFP_NOWAIT | __GFP_NOWARN);
|
|
if (!buf)
|
|
return;
|
|
|
|
nr_entries = stack_depot_fetch(stack_depot, &entries);
|
|
stack_trace_snprint(buf, PAGE_SIZE, entries, nr_entries, 2);
|
|
|
|
drm_printf(&p, "attempting to lock a contended lock without backoff:\n%s", buf);
|
|
|
|
kfree(buf);
|
|
}
|
|
|
|
static void __drm_stack_depot_init(void)
|
|
{
|
|
stack_depot_init();
|
|
}
|
|
#else /* CONFIG_DRM_DEBUG_MODESET_LOCK */
|
|
static depot_stack_handle_t __drm_stack_depot_save(void)
|
|
{
|
|
return 0;
|
|
}
|
|
static void __drm_stack_depot_print(depot_stack_handle_t stack_depot)
|
|
{
|
|
}
|
|
static void __drm_stack_depot_init(void)
|
|
{
|
|
}
|
|
#endif /* CONFIG_DRM_DEBUG_MODESET_LOCK */
|
|
|
|
/**
|
|
* drm_modeset_lock_all - take all modeset locks
|
|
* @dev: DRM device
|
|
*
|
|
* This function takes all modeset locks, suitable where a more fine-grained
|
|
* scheme isn't (yet) implemented. Locks must be dropped by calling the
|
|
* drm_modeset_unlock_all() function.
|
|
*
|
|
* This function is deprecated. It allocates a lock acquisition context and
|
|
* stores it in &drm_device.mode_config. This facilitate conversion of
|
|
* existing code because it removes the need to manually deal with the
|
|
* acquisition context, but it is also brittle because the context is global
|
|
* and care must be taken not to nest calls. New code should use the
|
|
* drm_modeset_lock_all_ctx() function and pass in the context explicitly.
|
|
*/
|
|
void drm_modeset_lock_all(struct drm_device *dev)
|
|
{
|
|
struct drm_mode_config *config = &dev->mode_config;
|
|
struct drm_modeset_acquire_ctx *ctx;
|
|
int ret;
|
|
|
|
ctx = kzalloc(sizeof(*ctx), GFP_KERNEL | __GFP_NOFAIL);
|
|
if (WARN_ON(!ctx))
|
|
return;
|
|
|
|
mutex_lock(&config->mutex);
|
|
|
|
drm_modeset_acquire_init(ctx, 0);
|
|
|
|
retry:
|
|
ret = drm_modeset_lock_all_ctx(dev, ctx);
|
|
if (ret < 0) {
|
|
if (ret == -EDEADLK) {
|
|
drm_modeset_backoff(ctx);
|
|
goto retry;
|
|
}
|
|
|
|
drm_modeset_acquire_fini(ctx);
|
|
kfree(ctx);
|
|
return;
|
|
}
|
|
ww_acquire_done(&ctx->ww_ctx);
|
|
|
|
WARN_ON(config->acquire_ctx);
|
|
|
|
/*
|
|
* We hold the locks now, so it is safe to stash the acquisition
|
|
* context for drm_modeset_unlock_all().
|
|
*/
|
|
config->acquire_ctx = ctx;
|
|
|
|
drm_warn_on_modeset_not_all_locked(dev);
|
|
}
|
|
EXPORT_SYMBOL(drm_modeset_lock_all);
|
|
|
|
/**
|
|
* drm_modeset_unlock_all - drop all modeset locks
|
|
* @dev: DRM device
|
|
*
|
|
* This function drops all modeset locks taken by a previous call to the
|
|
* drm_modeset_lock_all() function.
|
|
*
|
|
* This function is deprecated. It uses the lock acquisition context stored
|
|
* in &drm_device.mode_config. This facilitates conversion of existing
|
|
* code because it removes the need to manually deal with the acquisition
|
|
* context, but it is also brittle because the context is global and care must
|
|
* be taken not to nest calls. New code should pass the acquisition context
|
|
* directly to the drm_modeset_drop_locks() function.
|
|
*/
|
|
void drm_modeset_unlock_all(struct drm_device *dev)
|
|
{
|
|
struct drm_mode_config *config = &dev->mode_config;
|
|
struct drm_modeset_acquire_ctx *ctx = config->acquire_ctx;
|
|
|
|
if (WARN_ON(!ctx))
|
|
return;
|
|
|
|
config->acquire_ctx = NULL;
|
|
drm_modeset_drop_locks(ctx);
|
|
drm_modeset_acquire_fini(ctx);
|
|
|
|
kfree(ctx);
|
|
|
|
mutex_unlock(&dev->mode_config.mutex);
|
|
}
|
|
EXPORT_SYMBOL(drm_modeset_unlock_all);
|
|
|
|
/**
|
|
* drm_warn_on_modeset_not_all_locked - check that all modeset locks are locked
|
|
* @dev: device
|
|
*
|
|
* Useful as a debug assert.
|
|
*/
|
|
void drm_warn_on_modeset_not_all_locked(struct drm_device *dev)
|
|
{
|
|
struct drm_crtc *crtc;
|
|
|
|
/* Locking is currently fubar in the panic handler. */
|
|
if (oops_in_progress)
|
|
return;
|
|
|
|
drm_for_each_crtc(crtc, dev)
|
|
WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
|
|
|
|
WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
|
|
WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
|
|
}
|
|
EXPORT_SYMBOL(drm_warn_on_modeset_not_all_locked);
|
|
|
|
/**
|
|
* drm_modeset_acquire_init - initialize acquire context
|
|
* @ctx: the acquire context
|
|
* @flags: 0 or %DRM_MODESET_ACQUIRE_INTERRUPTIBLE
|
|
*
|
|
* When passing %DRM_MODESET_ACQUIRE_INTERRUPTIBLE to @flags,
|
|
* all calls to drm_modeset_lock() will perform an interruptible
|
|
* wait.
|
|
*/
|
|
void drm_modeset_acquire_init(struct drm_modeset_acquire_ctx *ctx,
|
|
uint32_t flags)
|
|
{
|
|
memset(ctx, 0, sizeof(*ctx));
|
|
ww_acquire_init(&ctx->ww_ctx, &crtc_ww_class);
|
|
INIT_LIST_HEAD(&ctx->locked);
|
|
|
|
if (flags & DRM_MODESET_ACQUIRE_INTERRUPTIBLE)
|
|
ctx->interruptible = true;
|
|
}
|
|
EXPORT_SYMBOL(drm_modeset_acquire_init);
|
|
|
|
/**
|
|
* drm_modeset_acquire_fini - cleanup acquire context
|
|
* @ctx: the acquire context
|
|
*/
|
|
void drm_modeset_acquire_fini(struct drm_modeset_acquire_ctx *ctx)
|
|
{
|
|
ww_acquire_fini(&ctx->ww_ctx);
|
|
}
|
|
EXPORT_SYMBOL(drm_modeset_acquire_fini);
|
|
|
|
/**
|
|
* drm_modeset_drop_locks - drop all locks
|
|
* @ctx: the acquire context
|
|
*
|
|
* Drop all locks currently held against this acquire context.
|
|
*/
|
|
void drm_modeset_drop_locks(struct drm_modeset_acquire_ctx *ctx)
|
|
{
|
|
if (WARN_ON(ctx->contended))
|
|
__drm_stack_depot_print(ctx->stack_depot);
|
|
|
|
while (!list_empty(&ctx->locked)) {
|
|
struct drm_modeset_lock *lock;
|
|
|
|
lock = list_first_entry(&ctx->locked,
|
|
struct drm_modeset_lock, head);
|
|
|
|
drm_modeset_unlock(lock);
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(drm_modeset_drop_locks);
|
|
|
|
static inline int modeset_lock(struct drm_modeset_lock *lock,
|
|
struct drm_modeset_acquire_ctx *ctx,
|
|
bool interruptible, bool slow)
|
|
{
|
|
int ret;
|
|
|
|
if (WARN_ON(ctx->contended))
|
|
__drm_stack_depot_print(ctx->stack_depot);
|
|
|
|
if (ctx->trylock_only) {
|
|
lockdep_assert_held(&ctx->ww_ctx);
|
|
|
|
if (!ww_mutex_trylock(&lock->mutex, NULL))
|
|
return -EBUSY;
|
|
else
|
|
return 0;
|
|
} else if (interruptible && slow) {
|
|
ret = ww_mutex_lock_slow_interruptible(&lock->mutex, &ctx->ww_ctx);
|
|
} else if (interruptible) {
|
|
ret = ww_mutex_lock_interruptible(&lock->mutex, &ctx->ww_ctx);
|
|
} else if (slow) {
|
|
ww_mutex_lock_slow(&lock->mutex, &ctx->ww_ctx);
|
|
ret = 0;
|
|
} else {
|
|
ret = ww_mutex_lock(&lock->mutex, &ctx->ww_ctx);
|
|
}
|
|
if (!ret) {
|
|
WARN_ON(!list_empty(&lock->head));
|
|
list_add(&lock->head, &ctx->locked);
|
|
} else if (ret == -EALREADY) {
|
|
/* we already hold the lock.. this is fine. For atomic
|
|
* we will need to be able to drm_modeset_lock() things
|
|
* without having to keep track of what is already locked
|
|
* or not.
|
|
*/
|
|
ret = 0;
|
|
} else if (ret == -EDEADLK) {
|
|
ctx->contended = lock;
|
|
ctx->stack_depot = __drm_stack_depot_save();
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* drm_modeset_backoff - deadlock avoidance backoff
|
|
* @ctx: the acquire context
|
|
*
|
|
* If deadlock is detected (ie. drm_modeset_lock() returns -EDEADLK),
|
|
* you must call this function to drop all currently held locks and
|
|
* block until the contended lock becomes available.
|
|
*
|
|
* This function returns 0 on success, or -ERESTARTSYS if this context
|
|
* is initialized with %DRM_MODESET_ACQUIRE_INTERRUPTIBLE and the
|
|
* wait has been interrupted.
|
|
*/
|
|
int drm_modeset_backoff(struct drm_modeset_acquire_ctx *ctx)
|
|
{
|
|
struct drm_modeset_lock *contended = ctx->contended;
|
|
|
|
ctx->contended = NULL;
|
|
ctx->stack_depot = 0;
|
|
|
|
if (WARN_ON(!contended))
|
|
return 0;
|
|
|
|
drm_modeset_drop_locks(ctx);
|
|
|
|
return modeset_lock(contended, ctx, ctx->interruptible, true);
|
|
}
|
|
EXPORT_SYMBOL(drm_modeset_backoff);
|
|
|
|
/**
|
|
* drm_modeset_lock_init - initialize lock
|
|
* @lock: lock to init
|
|
*/
|
|
void drm_modeset_lock_init(struct drm_modeset_lock *lock)
|
|
{
|
|
ww_mutex_init(&lock->mutex, &crtc_ww_class);
|
|
INIT_LIST_HEAD(&lock->head);
|
|
__drm_stack_depot_init();
|
|
}
|
|
EXPORT_SYMBOL(drm_modeset_lock_init);
|
|
|
|
/**
|
|
* drm_modeset_lock - take modeset lock
|
|
* @lock: lock to take
|
|
* @ctx: acquire ctx
|
|
*
|
|
* If @ctx is not NULL, then its ww acquire context is used and the
|
|
* lock will be tracked by the context and can be released by calling
|
|
* drm_modeset_drop_locks(). If -EDEADLK is returned, this means a
|
|
* deadlock scenario has been detected and it is an error to attempt
|
|
* to take any more locks without first calling drm_modeset_backoff().
|
|
*
|
|
* If the @ctx is not NULL and initialized with
|
|
* %DRM_MODESET_ACQUIRE_INTERRUPTIBLE, this function will fail with
|
|
* -ERESTARTSYS when interrupted.
|
|
*
|
|
* If @ctx is NULL then the function call behaves like a normal,
|
|
* uninterruptible non-nesting mutex_lock() call.
|
|
*/
|
|
int drm_modeset_lock(struct drm_modeset_lock *lock,
|
|
struct drm_modeset_acquire_ctx *ctx)
|
|
{
|
|
if (ctx)
|
|
return modeset_lock(lock, ctx, ctx->interruptible, false);
|
|
|
|
ww_mutex_lock(&lock->mutex, NULL);
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(drm_modeset_lock);
|
|
|
|
/**
|
|
* drm_modeset_lock_single_interruptible - take a single modeset lock
|
|
* @lock: lock to take
|
|
*
|
|
* This function behaves as drm_modeset_lock() with a NULL context,
|
|
* but performs interruptible waits.
|
|
*
|
|
* This function returns 0 on success, or -ERESTARTSYS when interrupted.
|
|
*/
|
|
int drm_modeset_lock_single_interruptible(struct drm_modeset_lock *lock)
|
|
{
|
|
return ww_mutex_lock_interruptible(&lock->mutex, NULL);
|
|
}
|
|
EXPORT_SYMBOL(drm_modeset_lock_single_interruptible);
|
|
|
|
/**
|
|
* drm_modeset_unlock - drop modeset lock
|
|
* @lock: lock to release
|
|
*/
|
|
void drm_modeset_unlock(struct drm_modeset_lock *lock)
|
|
{
|
|
list_del_init(&lock->head);
|
|
ww_mutex_unlock(&lock->mutex);
|
|
}
|
|
EXPORT_SYMBOL(drm_modeset_unlock);
|
|
|
|
/**
|
|
* drm_modeset_lock_all_ctx - take all modeset locks
|
|
* @dev: DRM device
|
|
* @ctx: lock acquisition context
|
|
*
|
|
* This function takes all modeset locks, suitable where a more fine-grained
|
|
* scheme isn't (yet) implemented.
|
|
*
|
|
* Unlike drm_modeset_lock_all(), it doesn't take the &drm_mode_config.mutex
|
|
* since that lock isn't required for modeset state changes. Callers which
|
|
* need to grab that lock too need to do so outside of the acquire context
|
|
* @ctx.
|
|
*
|
|
* Locks acquired with this function should be released by calling the
|
|
* drm_modeset_drop_locks() function on @ctx.
|
|
*
|
|
* See also: DRM_MODESET_LOCK_ALL_BEGIN() and DRM_MODESET_LOCK_ALL_END()
|
|
*
|
|
* Returns: 0 on success or a negative error-code on failure.
|
|
*/
|
|
int drm_modeset_lock_all_ctx(struct drm_device *dev,
|
|
struct drm_modeset_acquire_ctx *ctx)
|
|
{
|
|
struct drm_private_obj *privobj;
|
|
struct drm_crtc *crtc;
|
|
struct drm_plane *plane;
|
|
int ret;
|
|
|
|
ret = drm_modeset_lock(&dev->mode_config.connection_mutex, ctx);
|
|
if (ret)
|
|
return ret;
|
|
|
|
drm_for_each_crtc(crtc, dev) {
|
|
ret = drm_modeset_lock(&crtc->mutex, ctx);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
drm_for_each_plane(plane, dev) {
|
|
ret = drm_modeset_lock(&plane->mutex, ctx);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
drm_for_each_privobj(privobj, dev) {
|
|
ret = drm_modeset_lock(&privobj->lock, ctx);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(drm_modeset_lock_all_ctx);
|