WebSVN – Kolibri OS – Diff – /drivers/video/drm/ttm/ttm_execbuf_util.c

 /**************************************************************************
+ *
  * Copyright (c) 2006-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.
+ *
  **************************************************************************/
 #include
 #include
 #include
 #include
 #include
 #include
 DEFINE_WW_CLASS(reservation_ww_class);
+static void ttm_eu_backoff_reservation_reverse(struct list_head *list,
-static void ttm_eu_backoff_reservation_locked(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;
+		struct ttm_buffer_object *bo = entry->bo;
 		__ttm_bo_unreserve(bo);
+	}
+}
 static void ttm_eu_del_from_lru_locked(struct list_head *list)
+{
 	struct ttm_validate_buffer *entry;
 	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);
+		unsigned 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;
-		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);
+	}
+}
 void ttm_eu_backoff_reservation(struct ww_acquire_ctx *ticket,
 				struct list_head *list)
+{
 	struct ttm_validate_buffer *entry;
 	struct ttm_bo_global *glob;
 	if (list_empty(list))
 		return;
 	entry = list_first_entry(list, struct ttm_validate_buffer, head);
 	glob = entry->bo->glob;
 	spin_lock(&glob->lru_lock);
+	list_for_each_entry(entry, list, head) {
+		struct ttm_buffer_object *bo = entry->bo;
+		ttm_bo_add_to_lru(bo);
-	ttm_eu_backoff_reservation_locked(list);
+		__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);
 /*
  * Reserve buffers for validation.
+ *
  * If a buffer in the list is marked for CPU access, we back off and
  * wait for that buffer to become free for GPU access.
+ *
  * If a buffer is reserved for another validation, the validator with
  * the highest validation sequence backs off and waits for that buffer
  * to become unreserved. This prevents deadlocks when validating multiple
  * buffers in different orders.
  */
 int ttm_eu_reserve_buffers(struct ww_acquire_ctx *ticket,
+			   struct list_head *list, bool intr,
-			   struct list_head *list)
+			   struct list_head *dups)
+{
 	struct ttm_bo_global *glob;
 	struct ttm_validate_buffer *entry;
 	int ret;
 	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;
+		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;
+		} else if (ret == -EALREADY && dups) {
+			struct ttm_validate_buffer *safe = entry;
-		/* already slowpath reserved? */
+			entry = list_prev_entry(entry, head);
+			list_del(&safe->head);
-		if (entry->reserved)
+			list_add(&safe->head, dups);
+			continue;
+		}
+		if (!ret) {
+			if (!entry->shared)
 			continue;
+			ret = reservation_object_reserve_shared(bo->resv);
+			if (!ret)
-		ret = __ttm_bo_reserve(bo, true, (ticket == NULL), true,
-				       ticket);
+				continue;
+		}
 		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);
+		ttm_eu_backoff_reservation_reverse(list, entry);
-			spin_unlock(&glob->lru_lock);
-			ttm_eu_list_ref_sub(list);
+		if (ret == -EDEADLK && intr) {
 			ret = ww_mutex_lock_slow_interruptible(&bo->resv->lock,
 							       ticket);
+		} else if (ret == -EDEADLK) {
+			ww_mutex_lock_slow(&bo->resv->lock, ticket);
+			ret = 0;
+		}
+		if (!ret && entry->shared)
+			ret = reservation_object_reserve_shared(bo->resv);
 			if (unlikely(ret != 0)) {
 				if (ret == -EINTR)
 					ret = -ERESTARTSYS;
+			if (ticket) {
+				ww_acquire_done(ticket);
-				goto err_fini;
+				ww_acquire_fini(ticket);
+			}
-			entry->reserved = true;
-			if (unlikely(atomic_read(&bo->cpu_writers) > 0)) {
-				ret = -EBUSY;
+			return ret;
-				goto err;
+			}
-			goto retry;
-		} else if (ret)
-			goto err;
-		entry->reserved = true;
+		/* move this item to the front of the list,
-		if (unlikely(atomic_read(&bo->cpu_writers) > 0)) {
+		 * forces correct iteration of the loop without keeping track
-			ret = -EBUSY;
+		 */
-			goto err;
+		list_del(&entry->head);
 		list_add(&entry->head, list);
+	}
 	if (ticket)
 		ww_acquire_done(ticket);
 	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;
 	struct ttm_bo_global *glob;
 	struct ttm_bo_device *bdev;
 	struct ttm_bo_driver *driver;
 	if (list_empty(list))
 		return;
 	bo = list_first_entry(list, struct ttm_validate_buffer, head)->bo;
 	bdev = bo->bdev;
 	driver = bdev->driver;
 	glob = bo->glob;
 	spin_lock(&glob->lru_lock);
-	spin_lock(&bdev->fence_lock);
 	list_for_each_entry(entry, list, head) {
 		bo = entry->bo;
+		if (entry->shared)
-		entry->old_sync_obj = bo->sync_obj;
+			reservation_object_add_shared_fence(bo->resv, fence);
+		else
-		bo->sync_obj = driver->sync_obj_ref(sync_obj);
+			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);

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/ttm/ttm_execbuf_util.c – Rev 5078 → 5271