WebSVN – Kolibri OS – Diff – /drivers/include/drm/ttm/ttm_bo_driver.h

 #define _TTM_BO_DRIVER_H_
 #include
 #include
+#include
 #include
 #include
 #include
 //#include
 //#include
+#include
-#include
+struct ww_acquire_ctx;
 struct ttm_backend_func {
 	/**
 	 * struct ttm_backend_func member bind
  * ttm_bo_reserve:
+ *
  * @bo: A pointer to a struct ttm_buffer_object.
  * @interruptible: Sleep interruptible if waiting.
  * @no_wait: Don't sleep while trying to reserve, rather return -EBUSY.
- * @use_sequence: If @bo is already reserved, Only sleep waiting for
+ * @use_ticket: If @bo is already reserved, Only sleep waiting for
- * it to become unreserved if @sequence < (@bo)->sequence.
+ * it to become unreserved if @ticket->stamp is older.
+ *
  * Locks a buffer object for validation. (Or prevents other processes from
  * locking it for validation) and removes it from lru lists, while taking
  * a number of measures to prevent deadlocks.
+ *
  * Deadlocks may occur when two processes try to reserve multiple buffers in
  * different order, either by will or as a result of a buffer being evicted
  * to make room for a buffer already reserved. (Buffers are reserved before
  * they are evicted). The following algorithm prevents such deadlocks from
  * occurring:
- * 1) Buffers are reserved with the lru spinlock held. Upon successful
- * reservation they are removed from the lru list. This stops a reserved buffer
- * from being evicted. However the lru spinlock is released between the time
- * a buffer is selected for eviction and the time it is reserved.
- * Therefore a check is made when a buffer is reserved for eviction, that it
- * is still the first buffer in the lru list, before it is removed from the
- * list. @check_lru == 1 forces this check. If it fails, the function returns
- * -EINVAL, and the caller should then choose a new buffer to evict and repeat
- * the procedure.
- * 2) Processes attempting to reserve multiple buffers other than for eviction,
+ * Processes attempting to reserve multiple buffers other than for eviction,
  * (typically execbuf), should first obtain a unique 32-bit
  * validation sequence number,
- * and call this function with @use_sequence == 1 and @sequence == the unique
+ * and call this function with @use_ticket == 1 and @ticket->stamp == the unique
  * sequence number. If upon call of this function, the buffer object is already
  * reserved, the validation sequence is checked against the validation
  * sequence of the process currently reserving the buffer,
  * and if the current validation sequence is greater than that of the process
  * holding the reservation, the function returns -EAGAIN. Otherwise it sleeps
  * then rerun the validation with the same validation sequence. This procedure
  * will always guarantee that the process with the lowest validation sequence
  * will eventually succeed, preventing both deadlocks and starvation.
+ *
  * Returns:
- * -EAGAIN: The reservation may cause a deadlock.
+ * -EDEADLK: The reservation may cause a deadlock.
  * Release all buffer reservations, wait for @bo to become unreserved and
  * try again. (only if use_sequence == 1).
  * -ERESTARTSYS: A wait for the buffer to become unreserved was interrupted by
  * a signal. Release all buffer reservations and return to user-space.
  * -EBUSY: The function needed to sleep, but @no_wait was true
- * -EDEADLK: Bo already reserved using @sequence. This error code will only
+ * -EALREADY: Bo already reserved using @ticket. This error code will only
- * be returned if @use_sequence is set to true.
+ * be returned if @use_ticket is set to true.
  */
-extern int ttm_bo_reserve(struct ttm_buffer_object *bo,
+static inline int ttm_bo_reserve(struct ttm_buffer_object *bo,
 			  bool interruptible,
-			  bool no_wait, bool use_sequence, uint32_t sequence);
+				 bool no_wait, bool use_ticket,
+				 struct ww_acquire_ctx *ticket)
+{
+	int ret;
+	WARN_ON(!atomic_read(&bo->kref.refcount));
+	ret = ttm_bo_reserve_nolru(bo, interruptible, no_wait, use_ticket,
+				    ticket);
+	if (likely(ret == 0))
+		ttm_bo_del_sub_from_lru(bo);
+	return ret;
+}
-/**
- * ttm_bo_reserve_locked:
+/**
  * ttm_bo_reserve_slowpath:
- * @bo: A pointer to a struct ttm_buffer_object.
- * @interruptible: Sleep interruptible if waiting.
+ * @bo: A pointer to a struct ttm_buffer_object.
- * @no_wait: Don't sleep while trying to reserve, rather return -EBUSY.
- * @use_sequence: If @bo is already reserved, Only sleep waiting for
- * it to become unreserved if @sequence < (@bo)->sequence.
- *
- * Must be called with struct ttm_bo_global::lru_lock held,
- * and will not remove reserved buffers from the lru lists.
- * The function may release the LRU spinlock if it needs to sleep.
+ * @interruptible: Sleep interruptible if waiting.
- * Otherwise identical to ttm_bo_reserve.
- *
+ * @sequence: Set (@bo)->sequence to this value after lock
- * Returns:
+ *
- * -EAGAIN: The reservation may cause a deadlock.
- * Release all buffer reservations, wait for @bo to become unreserved and
- * try again. (only if use_sequence == 1).
- * -ERESTARTSYS: A wait for the buffer to become unreserved was interrupted by
- * a signal. Release all buffer reservations and return to user-space.
- * -EBUSY: The function needed to sleep, but @no_wait was true
+ * This is called after ttm_bo_reserve returns -EAGAIN and we backed off
- * -EDEADLK: Bo already reserved using @sequence. This error code will only
+ * from all our other reservations. Because there are no other reservations
- * be returned if @use_sequence is set to true.
+ * held by us, this function cannot deadlock any more.
  */
-extern int ttm_bo_reserve_locked(struct ttm_buffer_object *bo,
+static inline int ttm_bo_reserve_slowpath(struct ttm_buffer_object *bo,
+				 bool interruptible,
-				 bool interruptible,
+					  struct ww_acquire_ctx *ticket)
+{
-				 bool no_wait, bool use_sequence,
+	int ret = 0;
-				 uint32_t sequence);
+	WARN_ON(!atomic_read(&bo->kref.refcount));
+	if (interruptible)
-/**
+		ret = ww_mutex_lock_slow_interruptible(&bo->resv->lock,
- * ttm_bo_unreserve
+						       ticket);
+	else
+		ww_mutex_lock_slow(&bo->resv->lock, ticket);
- *
+	if (likely(ret == 0))
- * @bo: A pointer to a struct ttm_buffer_object.
+		ttm_bo_del_sub_from_lru(bo);
- *
+	else if (ret == -EINTR)
+		ret = -ERESTARTSYS;
  * Unreserve a previous reservation of @bo.
- */
+	return ret;
-extern void ttm_bo_unreserve(struct ttm_buffer_object *bo);
+}
 /**
- * ttm_bo_unreserve_locked
+ * ttm_bo_unreserve_ticket
- *
  * @bo: A pointer to a struct ttm_buffer_object.
- *
+ * @ticket: ww_acquire_ctx used for reserving
+ *
+ * Unreserve a previous reservation of @bo made with @ticket.
+ */
+static inline void ttm_bo_unreserve_ticket(struct ttm_buffer_object *bo,
+					   struct ww_acquire_ctx *t)
+{
+	if (!(bo->mem.placement & TTM_PL_FLAG_NO_EVICT)) {
+		spin_lock(&bo->glob->lru_lock);
+		ttm_bo_add_to_lru(bo);
- * Unreserve a previous reservation of @bo.
+		spin_unlock(&bo->glob->lru_lock);
- * Needs to be called with struct ttm_bo_global::lru_lock held.
+	}
- */
+	ww_mutex_unlock(&bo->resv->lock);
 extern void ttm_bo_unreserve_locked(struct ttm_buffer_object *bo);
-/**
- * ttm_bo_wait_unreserved
- *
+/**
- * @bo: A pointer to a struct ttm_buffer_object.
+ * ttm_bo_unreserve
  *
+ * @bo: A pointer to a struct ttm_buffer_object.
- * Wait for a struct ttm_buffer_object to become unreserved.
+ *
+ * Unreserve a previous reservation of @bo.
- * This is typically used in the execbuf code to relax cpu-usage when
+ */
- * a potential deadlock condition backoff.
+static inline void ttm_bo_unreserve(struct ttm_buffer_object *bo)
  */
+	ttm_bo_unreserve_ticket(bo, NULL);
+}
+/*
-extern int ttm_bo_wait_unreserved(struct ttm_buffer_object *bo,
+ * ttm_bo_util.c
-				  bool interruptible);
+ */
-/*
+int ttm_mem_io_reserve(struct ttm_bo_device *bdev,
- * ttm_bo_util.c
+		       struct ttm_mem_reg *mem);

Subversion Repositories Kolibri OS

(root)/drivers/include/drm/ttm/ttm_bo_driver.h – Rev 3262 → 4065