1 files changed, 63 insertions, 97 deletions

diff --git a/drivers/gpu/drm/ttm/ttm_execbuf_util.c b/drivers/gpu/drm/ttm/ttm_execbuf_util.c
index e8dac8758528..8ce508e76208 100644
--- a/drivers/gpu/drm/ttm/ttm_execbuf_util.c
+++ b/drivers/gpu/drm/ttm/ttm_execbuf_util.c
@@ -32,20 +32,12 @@
 #include <linux/sched.h>
 #include <linux/module.h>
 
-static void ttm_eu_backoff_reservation_locked(struct list_head *list)
+static void ttm_eu_backoff_reservation_reverse(struct list_head *list,
+                                              struct ttm_validate_buffer *entry)
 {
-        struct ttm_validate_buffer *entry;
-
-        list_for_each_entry(entry, list, head) {
+        list_for_each_entry_continue_reverse(entry, list, head) {
                 struct ttm_buffer_object *bo = entry->bo;
-                if (!entry->reserved)
-                        continue;
 
-                entry->reserved = false;
-                if (entry->removed) {
-                        ttm_bo_add_to_lru(bo);
-                        entry->removed = false;
-                }
                 __ttm_bo_unreserve(bo);
         }
 }
@@ -56,27 +48,9 @@ static void ttm_eu_del_from_lru_locked(struct list_head *list)
 
         list_for_each_entry(entry, list, head) {
                 struct ttm_buffer_object *bo = entry->bo;
-                if (!entry->reserved)
-                        continue;
-
-                if (!entry->removed) {
-                        entry->put_count = ttm_bo_del_from_lru(bo);
-                        entry->removed = true;
-                }
-        }
-}
-
-static void ttm_eu_list_ref_sub(struct list_head *list)
-{
-        struct ttm_validate_buffer *entry;
-
-        list_for_each_entry(entry, list, head) {
-                struct ttm_buffer_object *bo = entry->bo;
+                unsigned put_count = ttm_bo_del_from_lru(bo);
 
-                if (entry->put_count) {
-                        ttm_bo_list_ref_sub(bo, entry->put_count, true);
-                        entry->put_count = 0;
-                }
+                ttm_bo_list_ref_sub(bo, put_count, true);
         }
 }
 
@@ -91,11 +65,18 @@ void ttm_eu_backoff_reservation(struct ww_acquire_ctx *ticket,
 
         entry = list_first_entry(list, struct ttm_validate_buffer, head);
         glob = entry->bo->glob;
+
         spin_lock(&glob->lru_lock);
-        ttm_eu_backoff_reservation_locked(list);
+        list_for_each_entry(entry, list, head) {
+                struct ttm_buffer_object *bo = entry->bo;
+
+                ttm_bo_add_to_lru(bo);
+                __ttm_bo_unreserve(bo);
+        }
+        spin_unlock(&glob->lru_lock);
+
         if (ticket)
                 ww_acquire_fini(ticket);
-        spin_unlock(&glob->lru_lock);
 }
 EXPORT_SYMBOL(ttm_eu_backoff_reservation);
 
@@ -112,7 +93,7 @@ EXPORT_SYMBOL(ttm_eu_backoff_reservation);
  */
 
 int ttm_eu_reserve_buffers(struct ww_acquire_ctx *ticket,
-                           struct list_head *list)
+                           struct list_head *list, bool intr)
 {
         struct ttm_bo_global *glob;
         struct ttm_validate_buffer *entry;
@@ -121,60 +102,64 @@ int ttm_eu_reserve_buffers(struct ww_acquire_ctx *ticket,
         if (list_empty(list))
                 return 0;
 
-        list_for_each_entry(entry, list, head) {
-                entry->reserved = false;
-                entry->put_count = 0;
-                entry->removed = false;
-        }
-
         entry = list_first_entry(list, struct ttm_validate_buffer, head);
         glob = entry->bo->glob;
 
         if (ticket)
                 ww_acquire_init(ticket, &reservation_ww_class);
-retry:
+
         list_for_each_entry(entry, list, head) {
                 struct ttm_buffer_object *bo = entry->bo;
 
-                /* already slowpath reserved? */
-                if (entry->reserved)
-                        continue;
-
-                ret = __ttm_bo_reserve(bo, true, (ticket == NULL), true,
+                ret = __ttm_bo_reserve(bo, intr, (ticket == NULL), true,
                                        ticket);
+                if (!ret && unlikely(atomic_read(&bo->cpu_writers) > 0)) {
+                        __ttm_bo_unreserve(bo);
+
+                        ret = -EBUSY;
+                }
 
-                if (ret == -EDEADLK) {
-                        /* uh oh, we lost out, drop every reservation and try
-                         * to only reserve this buffer, then start over if
-                         * this succeeds.
-                         */
-                        BUG_ON(ticket == NULL);
-                        spin_lock(&glob->lru_lock);
-                        ttm_eu_backoff_reservation_locked(list);
-                        spin_unlock(&glob->lru_lock);
-                        ttm_eu_list_ref_sub(list);
+                if (!ret) {
+                        if (!entry->shared)
+                                continue;
+
+                        ret = reservation_object_reserve_shared(bo->resv);
+                        if (!ret)
+                                continue;
+                }
+
+                /* uh oh, we lost out, drop every reservation and try
+                 * to only reserve this buffer, then start over if
+                 * this succeeds.
+                 */
+                ttm_eu_backoff_reservation_reverse(list, entry);
+
+                if (ret == -EDEADLK && intr) {
                         ret = ww_mutex_lock_slow_interruptible(&bo->resv->lock,
                                                                ticket);
-                        if (unlikely(ret != 0)) {
-                                if (ret == -EINTR)
-                                        ret = -ERESTARTSYS;
-                                goto err_fini;
-                        }
+                } else if (ret == -EDEADLK) {
+                        ww_mutex_lock_slow(&bo->resv->lock, ticket);
+                        ret = 0;
+                }
 
-                        entry->reserved = true;
-                        if (unlikely(atomic_read(&bo->cpu_writers) > 0)) {
-                                ret = -EBUSY;
-                                goto err;
-                        }
-                        goto retry;
-                } else if (ret)
-                        goto err;
+                if (!ret && entry->shared)
+                        ret = reservation_object_reserve_shared(bo->resv);
 
-                entry->reserved = true;
-                if (unlikely(atomic_read(&bo->cpu_writers) > 0)) {
-                        ret = -EBUSY;
-                        goto err;
+                if (unlikely(ret != 0)) {
+                        if (ret == -EINTR)
+                                ret = -ERESTARTSYS;
+                        if (ticket) {
+                                ww_acquire_done(ticket);
+                                ww_acquire_fini(ticket);
+                        }
+                        return ret;
                 }
+
+                /* move this item to the front of the list,
+                 * forces correct iteration of the loop without keeping track
+                 */
+                list_del(&entry->head);
+                list_add(&entry->head, list);
         }
 
         if (ticket)
@@ -182,25 +167,12 @@ retry:
         spin_lock(&glob->lru_lock);
         ttm_eu_del_from_lru_locked(list);
         spin_unlock(&glob->lru_lock);
-        ttm_eu_list_ref_sub(list);
         return 0;
-
-err:
-        spin_lock(&glob->lru_lock);
-        ttm_eu_backoff_reservation_locked(list);
-        spin_unlock(&glob->lru_lock);
-        ttm_eu_list_ref_sub(list);
-err_fini:
-        if (ticket) {
-                ww_acquire_done(ticket);
-                ww_acquire_fini(ticket);
-        }
-        return ret;
 }
 EXPORT_SYMBOL(ttm_eu_reserve_buffers);
 
 void ttm_eu_fence_buffer_objects(struct ww_acquire_ctx *ticket,
-                                 struct list_head *list, void *sync_obj)
+                                 struct list_head *list, struct fence *fence)
 {
         struct ttm_validate_buffer *entry;
         struct ttm_buffer_object *bo;
@@ -217,24 +189,18 @@ void ttm_eu_fence_buffer_objects(struct ww_acquire_ctx *ticket,
         glob = bo->glob;
 
         spin_lock(&glob->lru_lock);
-        spin_lock(&bdev->fence_lock);
 
         list_for_each_entry(entry, list, head) {
                 bo = entry->bo;
-                entry->old_sync_obj = bo->sync_obj;
-                bo->sync_obj = driver->sync_obj_ref(sync_obj);
+                if (entry->shared)
+                        reservation_object_add_shared_fence(bo->resv, fence);
+                else
+                        reservation_object_add_excl_fence(bo->resv, fence);
                 ttm_bo_add_to_lru(bo);
                 __ttm_bo_unreserve(bo);
-                entry->reserved = false;
         }
-        spin_unlock(&bdev->fence_lock);
         spin_unlock(&glob->lru_lock);
         if (ticket)
                 ww_acquire_fini(ticket);
-
-        list_for_each_entry(entry, list, head) {
-                if (entry->old_sync_obj)
-                        driver->sync_obj_unref(&entry->old_sync_obj);
-        }
 }
 EXPORT_SYMBOL(ttm_eu_fence_buffer_objects);