Re: [PATCH] drm/ttm: move ttm_lock.c to drm/vmwgfx

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Dude, you're seriously overshooting here. This patch isn't required
_at_ _all_ to do cross device sharing/reservations/whatever. We've
simply discussed TTM documentation in the context of Maartens work,
and I've suggested to include all the TTM kerneldoc into a nice
DocBook. That way the kerneldoc stuff gets at least check for correct
parameters and similar trivial stuff (core drm sucked royally in that
regard). So Maarten jabbed around, I and Dave joined in and since
besides vmwgfx nothing else uses it at all I've figured this can't
hurt.

If you think all the radeon/nouveau/i915/whatever drivers are screwed
up beyond repair and need to have the ttm_lock.c file where it is as a
stern reminder, I don't care one bit. Personally I think the right
solution is to abolish the drm master concept entirely and aim for
CONFIG_VT=n. Insulation is a userspace problem which e.g. policykit or
whatever the latest thing is can do, or which should be solved for
real with per-process address spaces. Everything else smells too fishy
for me. So yeah, I don't think the fact that vmwgfx is the only driver
with a ->set_master and ->drop_master callback is a good sign, but
alas, not my driver and the core impact is negligible.

Cheers, Daniel

On Fri, Dec 14, 2012 at 4:51 PM, Thomas Hellström <thomas@xxxxxxxxxxxx> wrote:
> Nack,
>
> I'm not against moving the TTM lock away,
> when a replacement strategy for the main use case is presented.
>
> but using wording like "unholy", "scares" just because there is a lack of
> understanding or because it gets in the way of implementing cross-device
> reservation is a really really bad idea, and FWIW I think it's an even
> better idea to refrain from such wording unless you completely understand
> the problem and have a better solution in place.
>
> No other driver uses it, probably simply because the driver writers probably
> aren't aware of the use cases or don't implement parallel command
> submission.
>
> And if it weren't for the TTM lock, the cross device work wouldn't have to
> consider the case where a client
> needs to lock out other reservers, and the cross-device design would suffer.
>
> The main use cases are:
>
> 1) If we change master, clients of other masters need to be locked out from
> claiming memory resources (particularly VRAM).
> 2) If we're about to suspend and have cleaned VRAM, client's need to be
> stopped from validating VRAM buffer objects.
> 3) If a client needs access to the complete video memory space or need to
> defragment, it needs to lock out other reservers in a parallell command
> submission environment
>
> Now, present a better solution to those use cases, and I'll ack this patch
> and implement that solution, or
> leave the TTM lock in place as a reminder that these things need to be
> considered, and that we should have a common solution to them.
>
> /Thomas
>
>
>
>
>
> On 12/10/12 11:26 AM, Daniel Vetter wrote:
>>
>> ... it's the only user. Also move the header fil there.
>>
>> <mlankhorst> but seriously, ttm_lock is best left undocumented since
>> nobody should use that unholy thing..
>> <danvet> agreed ;-)
>> <danvet> imo we should shovel that under drm/vmwgfx ...
>> <airlied> amen
>> <airlied> that thing scares me
>> <danvet> out of sight, out of mind ...
>>
>> Signed-off-by: Daniel Vetter <daniel.vetter@xxxxxxxx>
>> ---
>>   drivers/gpu/drm/ttm/Makefile        |    2 +-
>>   drivers/gpu/drm/ttm/ttm_lock.c      |  310
>> -----------------------------------
>>   drivers/gpu/drm/vmwgfx/Makefile     |    2 +-
>>   drivers/gpu/drm/vmwgfx/ttm_lock.c   |  310
>> +++++++++++++++++++++++++++++++++++
>>   drivers/gpu/drm/vmwgfx/ttm_lock.h   |  247 ++++++++++++++++++++++++++++
>>   drivers/gpu/drm/vmwgfx/vmwgfx_drv.h |    2 +-
>>   include/drm/ttm/ttm_lock.h          |  247 ----------------------------
>>   7 files changed, 560 insertions(+), 560 deletions(-)
>>   delete mode 100644 drivers/gpu/drm/ttm/ttm_lock.c
>>   create mode 100644 drivers/gpu/drm/vmwgfx/ttm_lock.c
>>   create mode 100644 drivers/gpu/drm/vmwgfx/ttm_lock.h
>>   delete mode 100644 include/drm/ttm/ttm_lock.h
>>
>> diff --git a/drivers/gpu/drm/ttm/Makefile b/drivers/gpu/drm/ttm/Makefile
>> index b2b33dd..607a0b6 100644
>> --- a/drivers/gpu/drm/ttm/Makefile
>> +++ b/drivers/gpu/drm/ttm/Makefile
>> @@ -4,7 +4,7 @@
>>   ccflags-y := -Iinclude/drm
>>   ttm-y := ttm_agp_backend.o ttm_memory.o ttm_tt.o ttm_bo.o \
>>         ttm_bo_util.o ttm_bo_vm.o ttm_module.o \
>> -       ttm_object.o ttm_lock.o ttm_execbuf_util.o ttm_page_alloc.o \
>> +       ttm_object.o ttm_execbuf_util.o ttm_page_alloc.o \
>>         ttm_bo_manager.o
>>     ifeq ($(CONFIG_SWIOTLB),y)
>> diff --git a/drivers/gpu/drm/ttm/ttm_lock.c
>> b/drivers/gpu/drm/ttm/ttm_lock.c
>> deleted file mode 100644
>> index 3daa9a3..0000000
>> --- a/drivers/gpu/drm/ttm/ttm_lock.c
>> +++ /dev/null
>> @@ -1,310 +0,0 @@
>>
>> -/**************************************************************************
>> - *
>> - * Copyright (c) 2007-2009 VMware, Inc., Palo Alto, CA., USA
>> - * All Rights Reserved.
>> - *
>> - * 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, sub license, 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 (including the
>> - * next paragraph) 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 NON-INFRINGEMENT. IN NO EVENT
>> SHALL
>> - * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS 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.
>> - *
>> -
>> **************************************************************************/
>> -/*
>> - * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
>> - */
>> -
>> -#include <drm/ttm/ttm_lock.h>
>> -#include <drm/ttm/ttm_module.h>
>> -#include <linux/atomic.h>
>> -#include <linux/errno.h>
>> -#include <linux/wait.h>
>> -#include <linux/sched.h>
>> -#include <linux/module.h>
>> -
>> -#define TTM_WRITE_LOCK_PENDING    (1 << 0)
>> -#define TTM_VT_LOCK_PENDING       (1 << 1)
>> -#define TTM_SUSPEND_LOCK_PENDING  (1 << 2)
>> -#define TTM_VT_LOCK               (1 << 3)
>> -#define TTM_SUSPEND_LOCK          (1 << 4)
>> -
>> -void ttm_lock_init(struct ttm_lock *lock)
>> -{
>> -       spin_lock_init(&lock->lock);
>> -       init_waitqueue_head(&lock->queue);
>> -       lock->rw = 0;
>> -       lock->flags = 0;
>> -       lock->kill_takers = false;
>> -       lock->signal = SIGKILL;
>> -}
>> -EXPORT_SYMBOL(ttm_lock_init);
>> -
>> -void ttm_read_unlock(struct ttm_lock *lock)
>> -{
>> -       spin_lock(&lock->lock);
>> -       if (--lock->rw == 0)
>> -               wake_up_all(&lock->queue);
>> -       spin_unlock(&lock->lock);
>> -}
>> -EXPORT_SYMBOL(ttm_read_unlock);
>> -
>> -static bool __ttm_read_lock(struct ttm_lock *lock)
>> -{
>> -       bool locked = false;
>> -
>> -       spin_lock(&lock->lock);
>> -       if (unlikely(lock->kill_takers)) {
>> -               send_sig(lock->signal, current, 0);
>> -               spin_unlock(&lock->lock);
>> -               return false;
>> -       }
>> -       if (lock->rw >= 0 && lock->flags == 0) {
>> -               ++lock->rw;
>> -               locked = true;
>> -       }
>> -       spin_unlock(&lock->lock);
>> -       return locked;
>> -}
>> -
>> -int ttm_read_lock(struct ttm_lock *lock, bool interruptible)
>> -{
>> -       int ret = 0;
>> -
>> -       if (interruptible)
>> -               ret = wait_event_interruptible(lock->queue,
>> -                                              __ttm_read_lock(lock));
>> -       else
>> -               wait_event(lock->queue, __ttm_read_lock(lock));
>> -       return ret;
>> -}
>> -EXPORT_SYMBOL(ttm_read_lock);
>> -
>> -static bool __ttm_read_trylock(struct ttm_lock *lock, bool *locked)
>> -{
>> -       bool block = true;
>> -
>> -       *locked = false;
>> -
>> -       spin_lock(&lock->lock);
>> -       if (unlikely(lock->kill_takers)) {
>> -               send_sig(lock->signal, current, 0);
>> -               spin_unlock(&lock->lock);
>> -               return false;
>> -       }
>> -       if (lock->rw >= 0 && lock->flags == 0) {
>> -               ++lock->rw;
>> -               block = false;
>> -               *locked = true;
>> -       } else if (lock->flags == 0) {
>> -               block = false;
>> -       }
>> -       spin_unlock(&lock->lock);
>> -
>> -       return !block;
>> -}
>> -
>> -int ttm_read_trylock(struct ttm_lock *lock, bool interruptible)
>> -{
>> -       int ret = 0;
>> -       bool locked;
>> -
>> -       if (interruptible)
>> -               ret = wait_event_interruptible
>> -                       (lock->queue, __ttm_read_trylock(lock, &locked));
>> -       else
>> -               wait_event(lock->queue, __ttm_read_trylock(lock,
>> &locked));
>> -
>> -       if (unlikely(ret != 0)) {
>> -               BUG_ON(locked);
>> -               return ret;
>> -       }
>> -
>> -       return (locked) ? 0 : -EBUSY;
>> -}
>> -
>> -void ttm_write_unlock(struct ttm_lock *lock)
>> -{
>> -       spin_lock(&lock->lock);
>> -       lock->rw = 0;
>> -       wake_up_all(&lock->queue);
>> -       spin_unlock(&lock->lock);
>> -}
>> -EXPORT_SYMBOL(ttm_write_unlock);
>> -
>> -static bool __ttm_write_lock(struct ttm_lock *lock)
>> -{
>> -       bool locked = false;
>> -
>> -       spin_lock(&lock->lock);
>> -       if (unlikely(lock->kill_takers)) {
>> -               send_sig(lock->signal, current, 0);
>> -               spin_unlock(&lock->lock);
>> -               return false;
>> -       }
>> -       if (lock->rw == 0 && ((lock->flags & ~TTM_WRITE_LOCK_PENDING) ==
>> 0)) {
>> -               lock->rw = -1;
>> -               lock->flags &= ~TTM_WRITE_LOCK_PENDING;
>> -               locked = true;
>> -       } else {
>> -               lock->flags |= TTM_WRITE_LOCK_PENDING;
>> -       }
>> -       spin_unlock(&lock->lock);
>> -       return locked;
>> -}
>> -
>> -int ttm_write_lock(struct ttm_lock *lock, bool interruptible)
>> -{
>> -       int ret = 0;
>> -
>> -       if (interruptible) {
>> -               ret = wait_event_interruptible(lock->queue,
>> -                                              __ttm_write_lock(lock));
>> -               if (unlikely(ret != 0)) {
>> -                       spin_lock(&lock->lock);
>> -                       lock->flags &= ~TTM_WRITE_LOCK_PENDING;
>> -                       wake_up_all(&lock->queue);
>> -                       spin_unlock(&lock->lock);
>> -               }
>> -       } else
>> -               wait_event(lock->queue, __ttm_read_lock(lock));
>> -
>> -       return ret;
>> -}
>> -EXPORT_SYMBOL(ttm_write_lock);
>> -
>> -void ttm_write_lock_downgrade(struct ttm_lock *lock)
>> -{
>> -       spin_lock(&lock->lock);
>> -       lock->rw = 1;
>> -       wake_up_all(&lock->queue);
>> -       spin_unlock(&lock->lock);
>> -}
>> -
>> -static int __ttm_vt_unlock(struct ttm_lock *lock)
>> -{
>> -       int ret = 0;
>> -
>> -       spin_lock(&lock->lock);
>> -       if (unlikely(!(lock->flags & TTM_VT_LOCK)))
>> -               ret = -EINVAL;
>> -       lock->flags &= ~TTM_VT_LOCK;
>> -       wake_up_all(&lock->queue);
>> -       spin_unlock(&lock->lock);
>> -
>> -       return ret;
>> -}
>> -
>> -static void ttm_vt_lock_remove(struct ttm_base_object **p_base)
>> -{
>> -       struct ttm_base_object *base = *p_base;
>> -       struct ttm_lock *lock = container_of(base, struct ttm_lock, base);
>> -       int ret;
>> -
>> -       *p_base = NULL;
>> -       ret = __ttm_vt_unlock(lock);
>> -       BUG_ON(ret != 0);
>> -}
>> -
>> -static bool __ttm_vt_lock(struct ttm_lock *lock)
>> -{
>> -       bool locked = false;
>> -
>> -       spin_lock(&lock->lock);
>> -       if (lock->rw == 0) {
>> -               lock->flags &= ~TTM_VT_LOCK_PENDING;
>> -               lock->flags |= TTM_VT_LOCK;
>> -               locked = true;
>> -       } else {
>> -               lock->flags |= TTM_VT_LOCK_PENDING;
>> -       }
>> -       spin_unlock(&lock->lock);
>> -       return locked;
>> -}
>> -
>> -int ttm_vt_lock(struct ttm_lock *lock,
>> -               bool interruptible,
>> -               struct ttm_object_file *tfile)
>> -{
>> -       int ret = 0;
>> -
>> -       if (interruptible) {
>> -               ret = wait_event_interruptible(lock->queue,
>> -                                              __ttm_vt_lock(lock));
>> -               if (unlikely(ret != 0)) {
>> -                       spin_lock(&lock->lock);
>> -                       lock->flags &= ~TTM_VT_LOCK_PENDING;
>> -                       wake_up_all(&lock->queue);
>> -                       spin_unlock(&lock->lock);
>> -                       return ret;
>> -               }
>> -       } else
>> -               wait_event(lock->queue, __ttm_vt_lock(lock));
>> -
>> -       /*
>> -        * Add a base-object, the destructor of which will
>> -        * make sure the lock is released if the client dies
>> -        * while holding it.
>> -        */
>> -
>> -       ret = ttm_base_object_init(tfile, &lock->base, false,
>> -                                  ttm_lock_type, &ttm_vt_lock_remove,
>> NULL);
>> -       if (ret)
>> -               (void)__ttm_vt_unlock(lock);
>> -       else
>> -               lock->vt_holder = tfile;
>> -
>> -       return ret;
>> -}
>> -EXPORT_SYMBOL(ttm_vt_lock);
>> -
>> -int ttm_vt_unlock(struct ttm_lock *lock)
>> -{
>> -       return ttm_ref_object_base_unref(lock->vt_holder,
>> -                                        lock->base.hash.key,
>> TTM_REF_USAGE);
>> -}
>> -EXPORT_SYMBOL(ttm_vt_unlock);
>> -
>> -void ttm_suspend_unlock(struct ttm_lock *lock)
>> -{
>> -       spin_lock(&lock->lock);
>> -       lock->flags &= ~TTM_SUSPEND_LOCK;
>> -       wake_up_all(&lock->queue);
>> -       spin_unlock(&lock->lock);
>> -}
>> -EXPORT_SYMBOL(ttm_suspend_unlock);
>> -
>> -static bool __ttm_suspend_lock(struct ttm_lock *lock)
>> -{
>> -       bool locked = false;
>> -
>> -       spin_lock(&lock->lock);
>> -       if (lock->rw == 0) {
>> -               lock->flags &= ~TTM_SUSPEND_LOCK_PENDING;
>> -               lock->flags |= TTM_SUSPEND_LOCK;
>> -               locked = true;
>> -       } else {
>> -               lock->flags |= TTM_SUSPEND_LOCK_PENDING;
>> -       }
>> -       spin_unlock(&lock->lock);
>> -       return locked;
>> -}
>> -
>> -void ttm_suspend_lock(struct ttm_lock *lock)
>> -{
>> -       wait_event(lock->queue, __ttm_suspend_lock(lock));
>> -}
>> -EXPORT_SYMBOL(ttm_suspend_lock);
>> diff --git a/drivers/gpu/drm/vmwgfx/Makefile
>> b/drivers/gpu/drm/vmwgfx/Makefile
>> index 586869c..74bd973 100644
>> --- a/drivers/gpu/drm/vmwgfx/Makefile
>> +++ b/drivers/gpu/drm/vmwgfx/Makefile
>> @@ -5,6 +5,6 @@ vmwgfx-y := vmwgfx_execbuf.o vmwgfx_gmr.o vmwgfx_kms.o
>> vmwgfx_drv.o \
>>             vmwgfx_fb.o vmwgfx_ioctl.o vmwgfx_resource.o vmwgfx_buffer.o \
>>             vmwgfx_fifo.o vmwgfx_irq.o vmwgfx_ldu.o vmwgfx_ttm_glue.o \
>>             vmwgfx_overlay.o vmwgfx_marker.o vmwgfx_gmrid_manager.o \
>> -           vmwgfx_fence.o vmwgfx_dmabuf.o vmwgfx_scrn.o
>> +           vmwgfx_fence.o vmwgfx_dmabuf.o vmwgfx_scrn.o ttm_lock.o
>>     obj-$(CONFIG_DRM_VMWGFX) := vmwgfx.o
>> diff --git a/drivers/gpu/drm/vmwgfx/ttm_lock.c
>> b/drivers/gpu/drm/vmwgfx/ttm_lock.c
>> new file mode 100644
>> index 0000000..c859427
>> --- /dev/null
>> +++ b/drivers/gpu/drm/vmwgfx/ttm_lock.c
>> @@ -0,0 +1,310 @@
>>
>> +/**************************************************************************
>> + *
>> + * Copyright (c) 2007-2009 VMware, Inc., Palo Alto, CA., USA
>> + * All Rights Reserved.
>> + *
>> + * 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, sub license, 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 (including the
>> + * next paragraph) 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 NON-INFRINGEMENT. IN NO EVENT
>> SHALL
>> + * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS 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.
>> + *
>> +
>> **************************************************************************/
>> +/*
>> + * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
>> + */
>> +
>> +#include "ttm_lock.h"
>> +#include <drm/ttm/ttm_module.h>
>> +#include <linux/atomic.h>
>> +#include <linux/errno.h>
>> +#include <linux/wait.h>
>> +#include <linux/sched.h>
>> +#include <linux/module.h>
>> +
>> +#define TTM_WRITE_LOCK_PENDING    (1 << 0)
>> +#define TTM_VT_LOCK_PENDING       (1 << 1)
>> +#define TTM_SUSPEND_LOCK_PENDING  (1 << 2)
>> +#define TTM_VT_LOCK               (1 << 3)
>> +#define TTM_SUSPEND_LOCK          (1 << 4)
>> +
>> +void ttm_lock_init(struct ttm_lock *lock)
>> +{
>> +       spin_lock_init(&lock->lock);
>> +       init_waitqueue_head(&lock->queue);
>> +       lock->rw = 0;
>> +       lock->flags = 0;
>> +       lock->kill_takers = false;
>> +       lock->signal = SIGKILL;
>> +}
>> +EXPORT_SYMBOL(ttm_lock_init);
>> +
>> +void ttm_read_unlock(struct ttm_lock *lock)
>> +{
>> +       spin_lock(&lock->lock);
>> +       if (--lock->rw == 0)
>> +               wake_up_all(&lock->queue);
>> +       spin_unlock(&lock->lock);
>> +}
>> +EXPORT_SYMBOL(ttm_read_unlock);
>> +
>> +static bool __ttm_read_lock(struct ttm_lock *lock)
>> +{
>> +       bool locked = false;
>> +
>> +       spin_lock(&lock->lock);
>> +       if (unlikely(lock->kill_takers)) {
>> +               send_sig(lock->signal, current, 0);
>> +               spin_unlock(&lock->lock);
>> +               return false;
>> +       }
>> +       if (lock->rw >= 0 && lock->flags == 0) {
>> +               ++lock->rw;
>> +               locked = true;
>> +       }
>> +       spin_unlock(&lock->lock);
>> +       return locked;
>> +}
>> +
>> +int ttm_read_lock(struct ttm_lock *lock, bool interruptible)
>> +{
>> +       int ret = 0;
>> +
>> +       if (interruptible)
>> +               ret = wait_event_interruptible(lock->queue,
>> +                                              __ttm_read_lock(lock));
>> +       else
>> +               wait_event(lock->queue, __ttm_read_lock(lock));
>> +       return ret;
>> +}
>> +EXPORT_SYMBOL(ttm_read_lock);
>> +
>> +static bool __ttm_read_trylock(struct ttm_lock *lock, bool *locked)
>> +{
>> +       bool block = true;
>> +
>> +       *locked = false;
>> +
>> +       spin_lock(&lock->lock);
>> +       if (unlikely(lock->kill_takers)) {
>> +               send_sig(lock->signal, current, 0);
>> +               spin_unlock(&lock->lock);
>> +               return false;
>> +       }
>> +       if (lock->rw >= 0 && lock->flags == 0) {
>> +               ++lock->rw;
>> +               block = false;
>> +               *locked = true;
>> +       } else if (lock->flags == 0) {
>> +               block = false;
>> +       }
>> +       spin_unlock(&lock->lock);
>> +
>> +       return !block;
>> +}
>> +
>> +int ttm_read_trylock(struct ttm_lock *lock, bool interruptible)
>> +{
>> +       int ret = 0;
>> +       bool locked;
>> +
>> +       if (interruptible)
>> +               ret = wait_event_interruptible
>> +                       (lock->queue, __ttm_read_trylock(lock, &locked));
>> +       else
>> +               wait_event(lock->queue, __ttm_read_trylock(lock,
>> &locked));
>> +
>> +       if (unlikely(ret != 0)) {
>> +               BUG_ON(locked);
>> +               return ret;
>> +       }
>> +
>> +       return (locked) ? 0 : -EBUSY;
>> +}
>> +
>> +void ttm_write_unlock(struct ttm_lock *lock)
>> +{
>> +       spin_lock(&lock->lock);
>> +       lock->rw = 0;
>> +       wake_up_all(&lock->queue);
>> +       spin_unlock(&lock->lock);
>> +}
>> +EXPORT_SYMBOL(ttm_write_unlock);
>> +
>> +static bool __ttm_write_lock(struct ttm_lock *lock)
>> +{
>> +       bool locked = false;
>> +
>> +       spin_lock(&lock->lock);
>> +       if (unlikely(lock->kill_takers)) {
>> +               send_sig(lock->signal, current, 0);
>> +               spin_unlock(&lock->lock);
>> +               return false;
>> +       }
>> +       if (lock->rw == 0 && ((lock->flags & ~TTM_WRITE_LOCK_PENDING) ==
>> 0)) {
>> +               lock->rw = -1;
>> +               lock->flags &= ~TTM_WRITE_LOCK_PENDING;
>> +               locked = true;
>> +       } else {
>> +               lock->flags |= TTM_WRITE_LOCK_PENDING;
>> +       }
>> +       spin_unlock(&lock->lock);
>> +       return locked;
>> +}
>> +
>> +int ttm_write_lock(struct ttm_lock *lock, bool interruptible)
>> +{
>> +       int ret = 0;
>> +
>> +       if (interruptible) {
>> +               ret = wait_event_interruptible(lock->queue,
>> +                                              __ttm_write_lock(lock));
>> +               if (unlikely(ret != 0)) {
>> +                       spin_lock(&lock->lock);
>> +                       lock->flags &= ~TTM_WRITE_LOCK_PENDING;
>> +                       wake_up_all(&lock->queue);
>> +                       spin_unlock(&lock->lock);
>> +               }
>> +       } else
>> +               wait_event(lock->queue, __ttm_read_lock(lock));
>> +
>> +       return ret;
>> +}
>> +EXPORT_SYMBOL(ttm_write_lock);
>> +
>> +void ttm_write_lock_downgrade(struct ttm_lock *lock)
>> +{
>> +       spin_lock(&lock->lock);
>> +       lock->rw = 1;
>> +       wake_up_all(&lock->queue);
>> +       spin_unlock(&lock->lock);
>> +}
>> +
>> +static int __ttm_vt_unlock(struct ttm_lock *lock)
>> +{
>> +       int ret = 0;
>> +
>> +       spin_lock(&lock->lock);
>> +       if (unlikely(!(lock->flags & TTM_VT_LOCK)))
>> +               ret = -EINVAL;
>> +       lock->flags &= ~TTM_VT_LOCK;
>> +       wake_up_all(&lock->queue);
>> +       spin_unlock(&lock->lock);
>> +
>> +       return ret;
>> +}
>> +
>> +static void ttm_vt_lock_remove(struct ttm_base_object **p_base)
>> +{
>> +       struct ttm_base_object *base = *p_base;
>> +       struct ttm_lock *lock = container_of(base, struct ttm_lock, base);
>> +       int ret;
>> +
>> +       *p_base = NULL;
>> +       ret = __ttm_vt_unlock(lock);
>> +       BUG_ON(ret != 0);
>> +}
>> +
>> +static bool __ttm_vt_lock(struct ttm_lock *lock)
>> +{
>> +       bool locked = false;
>> +
>> +       spin_lock(&lock->lock);
>> +       if (lock->rw == 0) {
>> +               lock->flags &= ~TTM_VT_LOCK_PENDING;
>> +               lock->flags |= TTM_VT_LOCK;
>> +               locked = true;
>> +       } else {
>> +               lock->flags |= TTM_VT_LOCK_PENDING;
>> +       }
>> +       spin_unlock(&lock->lock);
>> +       return locked;
>> +}
>> +
>> +int ttm_vt_lock(struct ttm_lock *lock,
>> +               bool interruptible,
>> +               struct ttm_object_file *tfile)
>> +{
>> +       int ret = 0;
>> +
>> +       if (interruptible) {
>> +               ret = wait_event_interruptible(lock->queue,
>> +                                              __ttm_vt_lock(lock));
>> +               if (unlikely(ret != 0)) {
>> +                       spin_lock(&lock->lock);
>> +                       lock->flags &= ~TTM_VT_LOCK_PENDING;
>> +                       wake_up_all(&lock->queue);
>> +                       spin_unlock(&lock->lock);
>> +                       return ret;
>> +               }
>> +       } else
>> +               wait_event(lock->queue, __ttm_vt_lock(lock));
>> +
>> +       /*
>> +        * Add a base-object, the destructor of which will
>> +        * make sure the lock is released if the client dies
>> +        * while holding it.
>> +        */
>> +
>> +       ret = ttm_base_object_init(tfile, &lock->base, false,
>> +                                  ttm_lock_type, &ttm_vt_lock_remove,
>> NULL);
>> +       if (ret)
>> +               (void)__ttm_vt_unlock(lock);
>> +       else
>> +               lock->vt_holder = tfile;
>> +
>> +       return ret;
>> +}
>> +EXPORT_SYMBOL(ttm_vt_lock);
>> +
>> +int ttm_vt_unlock(struct ttm_lock *lock)
>> +{
>> +       return ttm_ref_object_base_unref(lock->vt_holder,
>> +                                        lock->base.hash.key,
>> TTM_REF_USAGE);
>> +}
>> +EXPORT_SYMBOL(ttm_vt_unlock);
>> +
>> +void ttm_suspend_unlock(struct ttm_lock *lock)
>> +{
>> +       spin_lock(&lock->lock);
>> +       lock->flags &= ~TTM_SUSPEND_LOCK;
>> +       wake_up_all(&lock->queue);
>> +       spin_unlock(&lock->lock);
>> +}
>> +EXPORT_SYMBOL(ttm_suspend_unlock);
>> +
>> +static bool __ttm_suspend_lock(struct ttm_lock *lock)
>> +{
>> +       bool locked = false;
>> +
>> +       spin_lock(&lock->lock);
>> +       if (lock->rw == 0) {
>> +               lock->flags &= ~TTM_SUSPEND_LOCK_PENDING;
>> +               lock->flags |= TTM_SUSPEND_LOCK;
>> +               locked = true;
>> +       } else {
>> +               lock->flags |= TTM_SUSPEND_LOCK_PENDING;
>> +       }
>> +       spin_unlock(&lock->lock);
>> +       return locked;
>> +}
>> +
>> +void ttm_suspend_lock(struct ttm_lock *lock)
>> +{
>> +       wait_event(lock->queue, __ttm_suspend_lock(lock));
>> +}
>> +EXPORT_SYMBOL(ttm_suspend_lock);
>> diff --git a/drivers/gpu/drm/vmwgfx/ttm_lock.h
>> b/drivers/gpu/drm/vmwgfx/ttm_lock.h
>> new file mode 100644
>> index 0000000..2902beb
>> --- /dev/null
>> +++ b/drivers/gpu/drm/vmwgfx/ttm_lock.h
>> @@ -0,0 +1,247 @@
>>
>> +/**************************************************************************
>> + *
>> + * Copyright (c) 2007-2009 VMware, Inc., Palo Alto, CA., USA
>> + * All Rights Reserved.
>> + *
>> + * 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, sub license, 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 (including the
>> + * next paragraph) 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 NON-INFRINGEMENT. IN NO EVENT
>> SHALL
>> + * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS 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.
>> + *
>> +
>> **************************************************************************/
>> +/*
>> + * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
>> + */
>> +
>> +/** @file ttm_lock.h
>> + * This file implements a simple replacement for the buffer manager use
>> + * of the DRM heavyweight hardware lock.
>> + * The lock is a read-write lock. Taking it in read mode and write mode
>> + * is relatively fast, and intended for in-kernel use only.
>> + *
>> + * The vt mode is used only when there is a need to block all
>> + * user-space processes from validating buffers.
>> + * It's allowed to leave kernel space with the vt lock held.
>> + * If a user-space process dies while having the vt-lock,
>> + * it will be released during the file descriptor release. The vt lock
>> + * excludes write lock and read lock.
>> + *
>> + * The suspend mode is used to lock out all TTM users when preparing for
>> + * and executing suspend operations.
>> + *
>> + */
>> +
>> +#ifndef _TTM_LOCK_H_
>> +#define _TTM_LOCK_H_
>> +
>> +#include <ttm/ttm_object.h>
>> +#include <linux/wait.h>
>> +#include <linux/atomic.h>
>> +
>> +/**
>> + * struct ttm_lock
>> + *
>> + * @base: ttm base object used solely to release the lock if the client
>> + * holding the lock dies.
>> + * @queue: Queue for processes waiting for lock change-of-status.
>> + * @lock: Spinlock protecting some lock members.
>> + * @rw: Read-write lock counter. Protected by @lock.
>> + * @flags: Lock state. Protected by @lock.
>> + * @kill_takers: Boolean whether to kill takers of the lock.
>> + * @signal: Signal to send when kill_takers is true.
>> + */
>> +
>> +struct ttm_lock {
>> +       struct ttm_base_object base;
>> +       wait_queue_head_t queue;
>> +       spinlock_t lock;
>> +       int32_t rw;
>> +       uint32_t flags;
>> +       bool kill_takers;
>> +       int signal;
>> +       struct ttm_object_file *vt_holder;
>> +};
>> +
>> +
>> +/**
>> + * ttm_lock_init
>> + *
>> + * @lock: Pointer to a struct ttm_lock
>> + * Initializes the lock.
>> + */
>> +extern void ttm_lock_init(struct ttm_lock *lock);
>> +
>> +/**
>> + * ttm_read_unlock
>> + *
>> + * @lock: Pointer to a struct ttm_lock
>> + *
>> + * Releases a read lock.
>> + */
>> +extern void ttm_read_unlock(struct ttm_lock *lock);
>> +
>> +/**
>> + * ttm_read_lock
>> + *
>> + * @lock: Pointer to a struct ttm_lock
>> + * @interruptible: Interruptible sleeping while waiting for a lock.
>> + *
>> + * Takes the lock in read mode.
>> + * Returns:
>> + * -ERESTARTSYS If interrupted by a signal and interruptible is true.
>> + */
>> +extern int ttm_read_lock(struct ttm_lock *lock, bool interruptible);
>> +
>> +/**
>> + * ttm_read_trylock
>> + *
>> + * @lock: Pointer to a struct ttm_lock
>> + * @interruptible: Interruptible sleeping while waiting for a lock.
>> + *
>> + * Tries to take the lock in read mode. If the lock is already held
>> + * in write mode, the function will return -EBUSY. If the lock is held
>> + * in vt or suspend mode, the function will sleep until these modes
>> + * are unlocked.
>> + *
>> + * Returns:
>> + * -EBUSY The lock was already held in write mode.
>> + * -ERESTARTSYS If interrupted by a signal and interruptible is true.
>> + */
>> +extern int ttm_read_trylock(struct ttm_lock *lock, bool interruptible);
>> +
>> +/**
>> + * ttm_write_unlock
>> + *
>> + * @lock: Pointer to a struct ttm_lock
>> + *
>> + * Releases a write lock.
>> + */
>> +extern void ttm_write_unlock(struct ttm_lock *lock);
>> +
>> +/**
>> + * ttm_write_lock
>> + *
>> + * @lock: Pointer to a struct ttm_lock
>> + * @interruptible: Interruptible sleeping while waiting for a lock.
>> + *
>> + * Takes the lock in write mode.
>> + * Returns:
>> + * -ERESTARTSYS If interrupted by a signal and interruptible is true.
>> + */
>> +extern int ttm_write_lock(struct ttm_lock *lock, bool interruptible);
>> +
>> +/**
>> + * ttm_lock_downgrade
>> + *
>> + * @lock: Pointer to a struct ttm_lock
>> + *
>> + * Downgrades a write lock to a read lock.
>> + */
>> +extern void ttm_lock_downgrade(struct ttm_lock *lock);
>> +
>> +/**
>> + * ttm_suspend_lock
>> + *
>> + * @lock: Pointer to a struct ttm_lock
>> + *
>> + * Takes the lock in suspend mode. Excludes read and write mode.
>> + */
>> +extern void ttm_suspend_lock(struct ttm_lock *lock);
>> +
>> +/**
>> + * ttm_suspend_unlock
>> + *
>> + * @lock: Pointer to a struct ttm_lock
>> + *
>> + * Releases a suspend lock
>> + */
>> +extern void ttm_suspend_unlock(struct ttm_lock *lock);
>> +
>> +/**
>> + * ttm_vt_lock
>> + *
>> + * @lock: Pointer to a struct ttm_lock
>> + * @interruptible: Interruptible sleeping while waiting for a lock.
>> + * @tfile: Pointer to a struct ttm_object_file to register the lock with.
>> + *
>> + * Takes the lock in vt mode.
>> + * Returns:
>> + * -ERESTARTSYS If interrupted by a signal and interruptible is true.
>> + * -ENOMEM: Out of memory when locking.
>> + */
>> +extern int ttm_vt_lock(struct ttm_lock *lock, bool interruptible,
>> +                      struct ttm_object_file *tfile);
>> +
>> +/**
>> + * ttm_vt_unlock
>> + *
>> + * @lock: Pointer to a struct ttm_lock
>> + *
>> + * Releases a vt lock.
>> + * Returns:
>> + * -EINVAL If the lock was not held.
>> + */
>> +extern int ttm_vt_unlock(struct ttm_lock *lock);
>> +
>> +/**
>> + * ttm_write_unlock
>> + *
>> + * @lock: Pointer to a struct ttm_lock
>> + *
>> + * Releases a write lock.
>> + */
>> +extern void ttm_write_unlock(struct ttm_lock *lock);
>> +
>> +/**
>> + * ttm_write_lock
>> + *
>> + * @lock: Pointer to a struct ttm_lock
>> + * @interruptible: Interruptible sleeping while waiting for a lock.
>> + *
>> + * Takes the lock in write mode.
>> + * Returns:
>> + * -ERESTARTSYS If interrupted by a signal and interruptible is true.
>> + */
>> +extern int ttm_write_lock(struct ttm_lock *lock, bool interruptible);
>> +
>> +/**
>> + * ttm_lock_set_kill
>> + *
>> + * @lock: Pointer to a struct ttm_lock
>> + * @val: Boolean whether to kill processes taking the lock.
>> + * @signal: Signal to send to the process taking the lock.
>> + *
>> + * The kill-when-taking-lock functionality is used to kill processes that
>> keep
>> + * on using the TTM functionality when its resources has been taken down,
>> for
>> + * example when the X server exits. A typical sequence would look like
>> this:
>> + * - X server takes lock in write mode.
>> + * - ttm_lock_set_kill() is called with @val set to true.
>> + * - As part of X server exit, TTM resources are taken down.
>> + * - X server releases the lock on file release.
>> + * - Another dri client wants to render, takes the lock and is killed.
>> + *
>> + */
>> +static inline void ttm_lock_set_kill(struct ttm_lock *lock, bool val,
>> +                                    int signal)
>> +{
>> +       lock->kill_takers = val;
>> +       if (val)
>> +               lock->signal = signal;
>> +}
>> +
>> +#endif
>> diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
>> b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
>> index 7c6f6e3..94e6de1 100644
>> --- a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
>> +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
>> @@ -35,7 +35,7 @@
>>   #include <linux/suspend.h>
>>   #include <drm/ttm/ttm_bo_driver.h>
>>   #include <drm/ttm/ttm_object.h>
>> -#include <drm/ttm/ttm_lock.h>
>> +#include "ttm_lock.h"
>>   #include <drm/ttm/ttm_execbuf_util.h>
>>   #include <drm/ttm/ttm_module.h>
>>   #include "vmwgfx_fence.h"
>> diff --git a/include/drm/ttm/ttm_lock.h b/include/drm/ttm/ttm_lock.h
>> deleted file mode 100644
>> index 2902beb..0000000
>> --- a/include/drm/ttm/ttm_lock.h
>> +++ /dev/null
>> @@ -1,247 +0,0 @@
>>
>> -/**************************************************************************
>> - *
>> - * Copyright (c) 2007-2009 VMware, Inc., Palo Alto, CA., USA
>> - * All Rights Reserved.
>> - *
>> - * 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, sub license, 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 (including the
>> - * next paragraph) 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 NON-INFRINGEMENT. IN NO EVENT
>> SHALL
>> - * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS 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.
>> - *
>> -
>> **************************************************************************/
>> -/*
>> - * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
>> - */
>> -
>> -/** @file ttm_lock.h
>> - * This file implements a simple replacement for the buffer manager use
>> - * of the DRM heavyweight hardware lock.
>> - * The lock is a read-write lock. Taking it in read mode and write mode
>> - * is relatively fast, and intended for in-kernel use only.
>> - *
>> - * The vt mode is used only when there is a need to block all
>> - * user-space processes from validating buffers.
>> - * It's allowed to leave kernel space with the vt lock held.
>> - * If a user-space process dies while having the vt-lock,
>> - * it will be released during the file descriptor release. The vt lock
>> - * excludes write lock and read lock.
>> - *
>> - * The suspend mode is used to lock out all TTM users when preparing for
>> - * and executing suspend operations.
>> - *
>> - */
>> -
>> -#ifndef _TTM_LOCK_H_
>> -#define _TTM_LOCK_H_
>> -
>> -#include <ttm/ttm_object.h>
>> -#include <linux/wait.h>
>> -#include <linux/atomic.h>
>> -
>> -/**
>> - * struct ttm_lock
>> - *
>> - * @base: ttm base object used solely to release the lock if the client
>> - * holding the lock dies.
>> - * @queue: Queue for processes waiting for lock change-of-status.
>> - * @lock: Spinlock protecting some lock members.
>> - * @rw: Read-write lock counter. Protected by @lock.
>> - * @flags: Lock state. Protected by @lock.
>> - * @kill_takers: Boolean whether to kill takers of the lock.
>> - * @signal: Signal to send when kill_takers is true.
>> - */
>> -
>> -struct ttm_lock {
>> -       struct ttm_base_object base;
>> -       wait_queue_head_t queue;
>> -       spinlock_t lock;
>> -       int32_t rw;
>> -       uint32_t flags;
>> -       bool kill_takers;
>> -       int signal;
>> -       struct ttm_object_file *vt_holder;
>> -};
>> -
>> -
>> -/**
>> - * ttm_lock_init
>> - *
>> - * @lock: Pointer to a struct ttm_lock
>> - * Initializes the lock.
>> - */
>> -extern void ttm_lock_init(struct ttm_lock *lock);
>> -
>> -/**
>> - * ttm_read_unlock
>> - *
>> - * @lock: Pointer to a struct ttm_lock
>> - *
>> - * Releases a read lock.
>> - */
>> -extern void ttm_read_unlock(struct ttm_lock *lock);
>> -
>> -/**
>> - * ttm_read_lock
>> - *
>> - * @lock: Pointer to a struct ttm_lock
>> - * @interruptible: Interruptible sleeping while waiting for a lock.
>> - *
>> - * Takes the lock in read mode.
>> - * Returns:
>> - * -ERESTARTSYS If interrupted by a signal and interruptible is true.
>> - */
>> -extern int ttm_read_lock(struct ttm_lock *lock, bool interruptible);
>> -
>> -/**
>> - * ttm_read_trylock
>> - *
>> - * @lock: Pointer to a struct ttm_lock
>> - * @interruptible: Interruptible sleeping while waiting for a lock.
>> - *
>> - * Tries to take the lock in read mode. If the lock is already held
>> - * in write mode, the function will return -EBUSY. If the lock is held
>> - * in vt or suspend mode, the function will sleep until these modes
>> - * are unlocked.
>> - *
>> - * Returns:
>> - * -EBUSY The lock was already held in write mode.
>> - * -ERESTARTSYS If interrupted by a signal and interruptible is true.
>> - */
>> -extern int ttm_read_trylock(struct ttm_lock *lock, bool interruptible);
>> -
>> -/**
>> - * ttm_write_unlock
>> - *
>> - * @lock: Pointer to a struct ttm_lock
>> - *
>> - * Releases a write lock.
>> - */
>> -extern void ttm_write_unlock(struct ttm_lock *lock);
>> -
>> -/**
>> - * ttm_write_lock
>> - *
>> - * @lock: Pointer to a struct ttm_lock
>> - * @interruptible: Interruptible sleeping while waiting for a lock.
>> - *
>> - * Takes the lock in write mode.
>> - * Returns:
>> - * -ERESTARTSYS If interrupted by a signal and interruptible is true.
>> - */
>> -extern int ttm_write_lock(struct ttm_lock *lock, bool interruptible);
>> -
>> -/**
>> - * ttm_lock_downgrade
>> - *
>> - * @lock: Pointer to a struct ttm_lock
>> - *
>> - * Downgrades a write lock to a read lock.
>> - */
>> -extern void ttm_lock_downgrade(struct ttm_lock *lock);
>> -
>> -/**
>> - * ttm_suspend_lock
>> - *
>> - * @lock: Pointer to a struct ttm_lock
>> - *
>> - * Takes the lock in suspend mode. Excludes read and write mode.
>> - */
>> -extern void ttm_suspend_lock(struct ttm_lock *lock);
>> -
>> -/**
>> - * ttm_suspend_unlock
>> - *
>> - * @lock: Pointer to a struct ttm_lock
>> - *
>> - * Releases a suspend lock
>> - */
>> -extern void ttm_suspend_unlock(struct ttm_lock *lock);
>> -
>> -/**
>> - * ttm_vt_lock
>> - *
>> - * @lock: Pointer to a struct ttm_lock
>> - * @interruptible: Interruptible sleeping while waiting for a lock.
>> - * @tfile: Pointer to a struct ttm_object_file to register the lock with.
>> - *
>> - * Takes the lock in vt mode.
>> - * Returns:
>> - * -ERESTARTSYS If interrupted by a signal and interruptible is true.
>> - * -ENOMEM: Out of memory when locking.
>> - */
>> -extern int ttm_vt_lock(struct ttm_lock *lock, bool interruptible,
>> -                      struct ttm_object_file *tfile);
>> -
>> -/**
>> - * ttm_vt_unlock
>> - *
>> - * @lock: Pointer to a struct ttm_lock
>> - *
>> - * Releases a vt lock.
>> - * Returns:
>> - * -EINVAL If the lock was not held.
>> - */
>> -extern int ttm_vt_unlock(struct ttm_lock *lock);
>> -
>> -/**
>> - * ttm_write_unlock
>> - *
>> - * @lock: Pointer to a struct ttm_lock
>> - *
>> - * Releases a write lock.
>> - */
>> -extern void ttm_write_unlock(struct ttm_lock *lock);
>> -
>> -/**
>> - * ttm_write_lock
>> - *
>> - * @lock: Pointer to a struct ttm_lock
>> - * @interruptible: Interruptible sleeping while waiting for a lock.
>> - *
>> - * Takes the lock in write mode.
>> - * Returns:
>> - * -ERESTARTSYS If interrupted by a signal and interruptible is true.
>> - */
>> -extern int ttm_write_lock(struct ttm_lock *lock, bool interruptible);
>> -
>> -/**
>> - * ttm_lock_set_kill
>> - *
>> - * @lock: Pointer to a struct ttm_lock
>> - * @val: Boolean whether to kill processes taking the lock.
>> - * @signal: Signal to send to the process taking the lock.
>> - *
>> - * The kill-when-taking-lock functionality is used to kill processes that
>> keep
>> - * on using the TTM functionality when its resources has been taken down,
>> for
>> - * example when the X server exits. A typical sequence would look like
>> this:
>> - * - X server takes lock in write mode.
>> - * - ttm_lock_set_kill() is called with @val set to true.
>> - * - As part of X server exit, TTM resources are taken down.
>> - * - X server releases the lock on file release.
>> - * - Another dri client wants to render, takes the lock and is killed.
>> - *
>> - */
>> -static inline void ttm_lock_set_kill(struct ttm_lock *lock, bool val,
>> -                                    int signal)
>> -{
>> -       lock->kill_takers = val;
>> -       if (val)
>> -               lock->signal = signal;
>> -}
>> -
>> -#endif
>
>
>
>



-- 
Daniel Vetter
Software Engineer, Intel Corporation
+41 (0) 79 365 57 48 - http://blog.ffwll.ch
_______________________________________________
dri-devel mailing list
dri-devel@xxxxxxxxxxxxxxxxxxxxx
http://lists.freedesktop.org/mailman/listinfo/dri-devel



[Index of Archives]     [Linux DRI Users]     [Linux Intel Graphics]     [Linux USB Devel]     [Video for Linux]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]     [XFree86]     [Linux USB Devel]     [Video for Linux]     [Linux Audio Users]     [Linux Kernel]     [Linux SCSI]     [XFree86]
  Powered by Linux