Revert "drm/ttm: add a way to bo_wait for either the last read or last write"
authorDave Airlie <airlied@redhat.com>
Thu, 27 Oct 2011 16:28:37 +0000 (18:28 +0200)
committerDave Airlie <airlied@redhat.com>
Thu, 27 Oct 2011 16:28:37 +0000 (18:28 +0200)
This reverts commit dfadbbdb57b3f2bb33e14f129a43047c6f0caefa.

Further upstream discussion between Marek and Thomas decided this wasn't
fully baked and needed further work, so revert it before it hits mainline.

Signed-off-by: Dave Airlie <airlied@redhat.com>
12 files changed:
drivers/gpu/drm/nouveau/nouveau_bo.c
drivers/gpu/drm/nouveau/nouveau_gem.c
drivers/gpu/drm/radeon/radeon_cs.c
drivers/gpu/drm/radeon/radeon_object.c
drivers/gpu/drm/ttm/ttm_bo.c
drivers/gpu/drm/ttm/ttm_bo_util.c
drivers/gpu/drm/ttm/ttm_bo_vm.c
drivers/gpu/drm/ttm/ttm_execbuf_util.c
drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
include/drm/ttm/ttm_bo_api.h
include/drm/ttm/ttm_execbuf_util.h

index 424dff5d0aba4751c9bcab8c6f641071ce28ec38..7226f419e178b64e76d9a65a7d341f1de874b746 100644 (file)
@@ -1104,8 +1104,7 @@ nouveau_bo_vma_del(struct nouveau_bo *nvbo, struct nouveau_vma *vma)
        if (vma->node) {
                if (nvbo->bo.mem.mem_type != TTM_PL_SYSTEM) {
                        spin_lock(&nvbo->bo.bdev->fence_lock);
-                       ttm_bo_wait(&nvbo->bo, false, false, false,
-                                   TTM_USAGE_READWRITE);
+                       ttm_bo_wait(&nvbo->bo, false, false, false);
                        spin_unlock(&nvbo->bo.bdev->fence_lock);
                        nouveau_vm_unmap(vma);
                }
index 322bf62a064567cbf93fc8815c0a162e8ee7633e..5f0bc57fdaab5e14f1c3bc9f6e049f02c43a5069 100644 (file)
@@ -589,8 +589,7 @@ nouveau_gem_pushbuf_reloc_apply(struct drm_device *dev,
                }
 
                spin_lock(&nvbo->bo.bdev->fence_lock);
-               ret = ttm_bo_wait(&nvbo->bo, false, false, false,
-                                 TTM_USAGE_READWRITE);
+               ret = ttm_bo_wait(&nvbo->bo, false, false, false);
                spin_unlock(&nvbo->bo.bdev->fence_lock);
                if (ret) {
                        NV_ERROR(dev, "reloc wait_idle failed: %d\n", ret);
@@ -826,7 +825,7 @@ nouveau_gem_ioctl_cpu_prep(struct drm_device *dev, void *data,
        nvbo = nouveau_gem_object(gem);
 
        spin_lock(&nvbo->bo.bdev->fence_lock);
-       ret = ttm_bo_wait(&nvbo->bo, true, true, no_wait, TTM_USAGE_READWRITE);
+       ret = ttm_bo_wait(&nvbo->bo, true, true, no_wait);
        spin_unlock(&nvbo->bo.bdev->fence_lock);
        drm_gem_object_unreference_unlocked(gem);
        return ret;
index 14e8531511057e5ecca25da1f8fe0afd8fde45c1..fae00c0d75aaf1fae7fcbfc9b504370f560f5d42 100644 (file)
@@ -80,7 +80,6 @@ int radeon_cs_parser_relocs(struct radeon_cs_parser *p)
                        p->relocs[i].lobj.wdomain = r->write_domain;
                        p->relocs[i].lobj.rdomain = r->read_domains;
                        p->relocs[i].lobj.tv.bo = &p->relocs[i].robj->tbo;
-                       p->relocs[i].lobj.tv.usage = TTM_USAGE_READWRITE;
                        p->relocs[i].handle = r->handle;
                        p->relocs[i].flags = r->flags;
                        radeon_bo_list_add_object(&p->relocs[i].lobj,
index b8f75f5d344bcb2ef22232388af8ec532386bad9..1c851521f458dfd515033818a2046e657272e4c0 100644 (file)
@@ -527,7 +527,7 @@ int radeon_bo_wait(struct radeon_bo *bo, u32 *mem_type, bool no_wait)
        if (mem_type)
                *mem_type = bo->tbo.mem.mem_type;
        if (bo->tbo.sync_obj)
-               r = ttm_bo_wait(&bo->tbo, true, true, no_wait, false);
+               r = ttm_bo_wait(&bo->tbo, true, true, no_wait);
        spin_unlock(&bo->tbo.bdev->fence_lock);
        ttm_bo_unreserve(&bo->tbo);
        return r;
index 50fc8e4c9a310c78b57ca4e749bc46eb1ea0a4f0..617b64678fc62f24c70df6ae3fd7ba3bc7d6c9bf 100644 (file)
@@ -499,7 +499,7 @@ static void ttm_bo_cleanup_refs_or_queue(struct ttm_buffer_object *bo)
        int ret;
 
        spin_lock(&bdev->fence_lock);
-       (void) ttm_bo_wait(bo, false, false, true, TTM_USAGE_READWRITE);
+       (void) ttm_bo_wait(bo, false, false, true);
        if (!bo->sync_obj) {
 
                spin_lock(&glob->lru_lock);
@@ -567,8 +567,7 @@ static int ttm_bo_cleanup_refs(struct ttm_buffer_object *bo,
 
 retry:
        spin_lock(&bdev->fence_lock);
-       ret = ttm_bo_wait(bo, false, interruptible, no_wait_gpu,
-                         TTM_USAGE_READWRITE);
+       ret = ttm_bo_wait(bo, false, interruptible, no_wait_gpu);
        spin_unlock(&bdev->fence_lock);
 
        if (unlikely(ret != 0))
@@ -727,8 +726,7 @@ static int ttm_bo_evict(struct ttm_buffer_object *bo, bool interruptible,
        int ret = 0;
 
        spin_lock(&bdev->fence_lock);
-       ret = ttm_bo_wait(bo, false, interruptible, no_wait_gpu,
-                         TTM_USAGE_READWRITE);
+       ret = ttm_bo_wait(bo, false, interruptible, no_wait_gpu);
        spin_unlock(&bdev->fence_lock);
 
        if (unlikely(ret != 0)) {
@@ -1075,8 +1073,7 @@ int ttm_bo_move_buffer(struct ttm_buffer_object *bo,
         * instead of doing it here.
         */
        spin_lock(&bdev->fence_lock);
-       ret = ttm_bo_wait(bo, false, interruptible, no_wait_gpu,
-                         TTM_USAGE_READWRITE);
+       ret = ttm_bo_wait(bo, false, interruptible, no_wait_gpu);
        spin_unlock(&bdev->fence_lock);
        if (ret)
                return ret;
@@ -1697,83 +1694,34 @@ out_unlock:
        return ret;
 }
 
-static void ttm_bo_unref_sync_obj_locked(struct ttm_buffer_object *bo,
-                                        void *sync_obj,
-                                        void **extra_sync_obj)
-{
-       struct ttm_bo_device *bdev = bo->bdev;
-       struct ttm_bo_driver *driver = bdev->driver;
-       void *tmp_obj = NULL, *tmp_obj_read = NULL, *tmp_obj_write = NULL;
-
-       /* We must unref the sync obj wherever it's ref'd.
-        * Note that if we unref bo->sync_obj, we can unref both the read
-        * and write sync objs too, because they can't be newer than
-        * bo->sync_obj, so they are no longer relevant. */
-       if (sync_obj == bo->sync_obj ||
-           sync_obj == bo->sync_obj_read) {
-               tmp_obj_read = bo->sync_obj_read;
-               bo->sync_obj_read = NULL;
-       }
-       if (sync_obj == bo->sync_obj ||
-           sync_obj == bo->sync_obj_write) {
-               tmp_obj_write = bo->sync_obj_write;
-               bo->sync_obj_write = NULL;
-       }
-       if (sync_obj == bo->sync_obj) {
-               tmp_obj = bo->sync_obj;
-               bo->sync_obj = NULL;
-       }
-
-       clear_bit(TTM_BO_PRIV_FLAG_MOVING, &bo->priv_flags);
-       spin_unlock(&bdev->fence_lock);
-       if (tmp_obj)
-               driver->sync_obj_unref(&tmp_obj);
-       if (tmp_obj_read)
-               driver->sync_obj_unref(&tmp_obj_read);
-       if (tmp_obj_write)
-               driver->sync_obj_unref(&tmp_obj_write);
-       if (extra_sync_obj)
-               driver->sync_obj_unref(extra_sync_obj);
-       spin_lock(&bdev->fence_lock);
-}
-
 int ttm_bo_wait(struct ttm_buffer_object *bo,
-               bool lazy, bool interruptible, bool no_wait,
-               enum ttm_buffer_usage usage)
+               bool lazy, bool interruptible, bool no_wait)
 {
        struct ttm_bo_driver *driver = bo->bdev->driver;
        struct ttm_bo_device *bdev = bo->bdev;
        void *sync_obj;
        void *sync_obj_arg;
        int ret = 0;
-       void **bo_sync_obj;
 
-       switch (usage) {
-       case TTM_USAGE_READ:
-               bo_sync_obj = &bo->sync_obj_read;
-               break;
-       case TTM_USAGE_WRITE:
-               bo_sync_obj = &bo->sync_obj_write;
-               break;
-       case TTM_USAGE_READWRITE:
-       default:
-               bo_sync_obj = &bo->sync_obj;
-       }
-
-       if (likely(*bo_sync_obj == NULL))
+       if (likely(bo->sync_obj == NULL))
                return 0;
 
-       while (*bo_sync_obj) {
+       while (bo->sync_obj) {
 
-               if (driver->sync_obj_signaled(*bo_sync_obj, bo->sync_obj_arg)) {
-                       ttm_bo_unref_sync_obj_locked(bo, *bo_sync_obj, NULL);
+               if (driver->sync_obj_signaled(bo->sync_obj, bo->sync_obj_arg)) {
+                       void *tmp_obj = bo->sync_obj;
+                       bo->sync_obj = NULL;
+                       clear_bit(TTM_BO_PRIV_FLAG_MOVING, &bo->priv_flags);
+                       spin_unlock(&bdev->fence_lock);
+                       driver->sync_obj_unref(&tmp_obj);
+                       spin_lock(&bdev->fence_lock);
                        continue;
                }
 
                if (no_wait)
                        return -EBUSY;
 
-               sync_obj = driver->sync_obj_ref(*bo_sync_obj);
+               sync_obj = driver->sync_obj_ref(bo->sync_obj);
                sync_obj_arg = bo->sync_obj_arg;
                spin_unlock(&bdev->fence_lock);
                ret = driver->sync_obj_wait(sync_obj, sync_obj_arg,
@@ -1784,9 +1732,16 @@ int ttm_bo_wait(struct ttm_buffer_object *bo,
                        return ret;
                }
                spin_lock(&bdev->fence_lock);
-               if (likely(*bo_sync_obj == sync_obj &&
+               if (likely(bo->sync_obj == sync_obj &&
                           bo->sync_obj_arg == sync_obj_arg)) {
-                       ttm_bo_unref_sync_obj_locked(bo, *bo_sync_obj, &sync_obj);
+                       void *tmp_obj = bo->sync_obj;
+                       bo->sync_obj = NULL;
+                       clear_bit(TTM_BO_PRIV_FLAG_MOVING,
+                                 &bo->priv_flags);
+                       spin_unlock(&bdev->fence_lock);
+                       driver->sync_obj_unref(&sync_obj);
+                       driver->sync_obj_unref(&tmp_obj);
+                       spin_lock(&bdev->fence_lock);
                } else {
                        spin_unlock(&bdev->fence_lock);
                        driver->sync_obj_unref(&sync_obj);
@@ -1810,7 +1765,7 @@ int ttm_bo_synccpu_write_grab(struct ttm_buffer_object *bo, bool no_wait)
        if (unlikely(ret != 0))
                return ret;
        spin_lock(&bdev->fence_lock);
-       ret = ttm_bo_wait(bo, false, true, no_wait, TTM_USAGE_READWRITE);
+       ret = ttm_bo_wait(bo, false, true, no_wait);
        spin_unlock(&bdev->fence_lock);
        if (likely(ret == 0))
                atomic_inc(&bo->cpu_writers);
@@ -1884,7 +1839,7 @@ static int ttm_bo_swapout(struct ttm_mem_shrink *shrink)
         */
 
        spin_lock(&bo->bdev->fence_lock);
-       ret = ttm_bo_wait(bo, false, false, false, TTM_USAGE_READWRITE);
+       ret = ttm_bo_wait(bo, false, false, false);
        spin_unlock(&bo->bdev->fence_lock);
 
        if (unlikely(ret != 0))
index 6135f58169ce7c95522fae6b1ea4d97e397c27fe..ae3c6f5dd2b71acee36f863deafc3896a874010e 100644 (file)
@@ -436,8 +436,6 @@ static int ttm_buffer_object_transfer(struct ttm_buffer_object *bo,
        atomic_set(&fbo->cpu_writers, 0);
 
        fbo->sync_obj = driver->sync_obj_ref(bo->sync_obj);
-       fbo->sync_obj_read = driver->sync_obj_ref(bo->sync_obj_read);
-       fbo->sync_obj_write = driver->sync_obj_ref(bo->sync_obj_write);
        kref_init(&fbo->list_kref);
        kref_init(&fbo->kref);
        fbo->destroy = &ttm_transfered_destroy;
@@ -620,30 +618,20 @@ int ttm_bo_move_accel_cleanup(struct ttm_buffer_object *bo,
        struct ttm_mem_reg *old_mem = &bo->mem;
        int ret;
        struct ttm_buffer_object *ghost_obj;
-       void *tmp_obj = NULL, *tmp_obj_read = NULL, *tmp_obj_write = NULL;
+       void *tmp_obj = NULL;
 
        spin_lock(&bdev->fence_lock);
-       if (bo->sync_obj)
+       if (bo->sync_obj) {
                tmp_obj = bo->sync_obj;
-       if (bo->sync_obj_read)
-               tmp_obj_read = bo->sync_obj_read;
-       if (bo->sync_obj_write)
-               tmp_obj_write = bo->sync_obj_write;
-
+               bo->sync_obj = NULL;
+       }
        bo->sync_obj = driver->sync_obj_ref(sync_obj);
-       bo->sync_obj_read = driver->sync_obj_ref(sync_obj);
-       bo->sync_obj_write = driver->sync_obj_ref(sync_obj);
        bo->sync_obj_arg = sync_obj_arg;
        if (evict) {
-               ret = ttm_bo_wait(bo, false, false, false,
-                                 TTM_USAGE_READWRITE);
+               ret = ttm_bo_wait(bo, false, false, false);
                spin_unlock(&bdev->fence_lock);
                if (tmp_obj)
                        driver->sync_obj_unref(&tmp_obj);
-               if (tmp_obj_read)
-                       driver->sync_obj_unref(&tmp_obj_read);
-               if (tmp_obj_write)
-                       driver->sync_obj_unref(&tmp_obj_write);
                if (ret)
                        return ret;
 
@@ -667,10 +655,6 @@ int ttm_bo_move_accel_cleanup(struct ttm_buffer_object *bo,
                spin_unlock(&bdev->fence_lock);
                if (tmp_obj)
                        driver->sync_obj_unref(&tmp_obj);
-               if (tmp_obj_read)
-                       driver->sync_obj_unref(&tmp_obj_read);
-               if (tmp_obj_write)
-                       driver->sync_obj_unref(&tmp_obj_write);
 
                ret = ttm_buffer_object_transfer(bo, &ghost_obj);
                if (ret)
index ff1e26f4b094f850c1b424153c7377a2452ea16a..221b924acebe273fb8b19080cd5a90b026256e73 100644 (file)
@@ -122,7 +122,7 @@ static int ttm_bo_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 
        spin_lock(&bdev->fence_lock);
        if (test_bit(TTM_BO_PRIV_FLAG_MOVING, &bo->priv_flags)) {
-               ret = ttm_bo_wait(bo, false, true, false, TTM_USAGE_READWRITE);
+               ret = ttm_bo_wait(bo, false, true, false);
                spin_unlock(&bdev->fence_lock);
                if (unlikely(ret != 0)) {
                        retval = (ret != -ERESTARTSYS) ?
index 36d111a882328a52a6d564ffa32b37e15ce22152..3832fe10b4dffe100ac44c05397819e140822356 100644 (file)
@@ -221,18 +221,8 @@ void ttm_eu_fence_buffer_objects(struct list_head *list, void *sync_obj)
 
        list_for_each_entry(entry, list, head) {
                bo = entry->bo;
-               entry->old_sync_obj_read = NULL;
-               entry->old_sync_obj_write = NULL;
                entry->old_sync_obj = bo->sync_obj;
                bo->sync_obj = driver->sync_obj_ref(sync_obj);
-               if (entry->usage & TTM_USAGE_READ) {
-                       entry->old_sync_obj_read = bo->sync_obj_read;
-                       bo->sync_obj_read = driver->sync_obj_ref(sync_obj);
-               }
-               if (entry->usage & TTM_USAGE_WRITE) {
-                       entry->old_sync_obj_write = bo->sync_obj_write;
-                       bo->sync_obj_write = driver->sync_obj_ref(sync_obj);
-               }
                bo->sync_obj_arg = entry->new_sync_obj_arg;
                ttm_bo_unreserve_locked(bo);
                entry->reserved = false;
@@ -241,15 +231,8 @@ void ttm_eu_fence_buffer_objects(struct list_head *list, void *sync_obj)
        spin_unlock(&bdev->fence_lock);
 
        list_for_each_entry(entry, list, head) {
-               if (entry->old_sync_obj) {
+               if (entry->old_sync_obj)
                        driver->sync_obj_unref(&entry->old_sync_obj);
-               }
-               if (entry->old_sync_obj_read) {
-                       driver->sync_obj_unref(&entry->old_sync_obj_read);
-               }
-               if (entry->old_sync_obj_write) {
-                       driver->sync_obj_unref(&entry->old_sync_obj_write);
-               }
        }
 }
 EXPORT_SYMBOL(ttm_eu_fence_buffer_objects);
index b8eb8cdcfb78bae7557411a4325e0c5d2c315f7d..13afddc1f034440b054522dfbe85d9640bea2b11 100644 (file)
@@ -244,7 +244,7 @@ static void vmw_dummy_query_bo_prepare(struct vmw_private *dev_priv)
 
        ttm_bo_reserve(bo, false, false, false, 0);
        spin_lock(&bdev->fence_lock);
-       ret = ttm_bo_wait(bo, false, false, false, TTM_USAGE_READWRITE);
+       ret = ttm_bo_wait(bo, false, false, false);
        spin_unlock(&bdev->fence_lock);
        if (unlikely(ret != 0))
                (void) vmw_fallback_wait(dev_priv, false, true, 0, false,
index 28e1c35aec6f28aa5ec1ee7bab53c4454649b78c..40932fbdac0f1a1bd460155c6bcdb8ee9e0b1acb 100644 (file)
@@ -89,7 +89,6 @@ static int vmw_bo_to_validate_list(struct vmw_sw_context *sw_context,
        if (unlikely(val_node == sw_context->cur_val_buf)) {
                val_buf->new_sync_obj_arg = NULL;
                val_buf->bo = ttm_bo_reference(bo);
-               val_buf->usage = TTM_USAGE_READWRITE;
                list_add_tail(&val_buf->head, &sw_context->validate_nodes);
                ++sw_context->cur_val_buf;
        }
index da957bf3fe449e0b8f4cfbed64f1652840c8bb37..42e34698518643d346e1b23c6aa08640f93eabe4 100644 (file)
@@ -44,11 +44,6 @@ struct ttm_bo_device;
 
 struct drm_mm_node;
 
-enum ttm_buffer_usage {
-    TTM_USAGE_READ = 1,
-    TTM_USAGE_WRITE = 2,
-    TTM_USAGE_READWRITE = TTM_USAGE_READ | TTM_USAGE_WRITE
-};
 
 /**
  * struct ttm_placement
@@ -179,10 +174,7 @@ struct ttm_tt;
  * the bo_device::lru_lock.
  * @reserved: Deadlock-free lock used for synchronization state transitions.
  * @sync_obj_arg: Opaque argument to synchronization object function.
- * @sync_obj: Pointer to a synchronization object of a last read or write,
- * whichever is later.
- * @sync_obj_read: Pointer to a synchronization object of a last read.
- * @sync_obj_write: Pointer to a synchronization object of a last write.
+ * @sync_obj: Pointer to a synchronization object.
  * @priv_flags: Flags describing buffer object internal state.
  * @vm_rb: Rb node for the vm rb tree.
  * @vm_node: Address space manager node.
@@ -266,8 +258,6 @@ struct ttm_buffer_object {
 
        void *sync_obj_arg;
        void *sync_obj;
-       void *sync_obj_read;
-       void *sync_obj_write;
        unsigned long priv_flags;
 
        /**
@@ -335,7 +325,6 @@ ttm_bo_reference(struct ttm_buffer_object *bo)
  * @bo:  The buffer object.
  * @interruptible:  Use interruptible wait.
  * @no_wait:  Return immediately if buffer is busy.
- * @usage:  Whether to wait for the last read and/or the last write.
  *
  * This function must be called with the bo::mutex held, and makes
  * sure any previous rendering to the buffer is completed.
@@ -345,8 +334,7 @@ ttm_bo_reference(struct ttm_buffer_object *bo)
  * Returns -ERESTARTSYS if interrupted by a signal.
  */
 extern int ttm_bo_wait(struct ttm_buffer_object *bo, bool lazy,
-                      bool interruptible, bool no_wait,
-                      enum ttm_buffer_usage usage);
+                      bool interruptible, bool no_wait);
 /**
  * ttm_bo_validate
  *
index 375f29902295d29a1a4702c5fa40e55e525df1f2..26cc7f9ffa411ab7257f87545cd766be8c5b182a 100644 (file)
  * @bo:             refcounted buffer object pointer.
  * @new_sync_obj_arg: New sync_obj_arg for @bo, to be used once
  * adding a new sync object.
- * @usage           Indicates how @bo is used by the device.
  * @reserved:       Indicates whether @bo has been reserved for validation.
  * @removed:        Indicates whether @bo has been removed from lru lists.
  * @put_count:      Number of outstanding references on bo::list_kref.
  * @old_sync_obj:   Pointer to a sync object about to be unreferenced
- * @old_sync_obj_read: Pointer to a read sync object about to be unreferenced.
- * @old_sync_obj_write: Pointer to a write sync object about to be unreferenced.
  */
 
 struct ttm_validate_buffer {
        struct list_head head;
        struct ttm_buffer_object *bo;
        void *new_sync_obj_arg;
-       enum ttm_buffer_usage usage;
        bool reserved;
        bool removed;
        int put_count;
        void *old_sync_obj;
-       void *old_sync_obj_read;
-       void *old_sync_obj_write;
 };
 
 /**