2 * SPDX-License-Identifier: MIT
4 * (C) Copyright 2016 Intel Corporation
7 #include <linux/slab.h>
8 #include <linux/dma-fence.h>
9 #include <linux/irq_work.h>
10 #include <linux/reservation.h>
12 #include "i915_sw_fence.h"
13 #include "i915_selftest.h"
15 #define I915_SW_FENCE_FLAG_ALLOC BIT(3) /* after WQ_FLAG_* for safety */
17 static DEFINE_SPINLOCK(i915_sw_fence_lock);
24 static void *i915_sw_fence_debug_hint(void *addr)
26 return (void *)(((struct i915_sw_fence *)addr)->flags & I915_SW_FENCE_MASK);
29 #ifdef CONFIG_DRM_I915_SW_FENCE_DEBUG_OBJECTS
31 static struct debug_obj_descr i915_sw_fence_debug_descr = {
32 .name = "i915_sw_fence",
33 .debug_hint = i915_sw_fence_debug_hint,
36 static inline void debug_fence_init(struct i915_sw_fence *fence)
38 debug_object_init(fence, &i915_sw_fence_debug_descr);
41 static inline void debug_fence_init_onstack(struct i915_sw_fence *fence)
43 debug_object_init_on_stack(fence, &i915_sw_fence_debug_descr);
46 static inline void debug_fence_activate(struct i915_sw_fence *fence)
48 debug_object_activate(fence, &i915_sw_fence_debug_descr);
51 static inline void debug_fence_set_state(struct i915_sw_fence *fence,
54 debug_object_active_state(fence, &i915_sw_fence_debug_descr, old, new);
57 static inline void debug_fence_deactivate(struct i915_sw_fence *fence)
59 debug_object_deactivate(fence, &i915_sw_fence_debug_descr);
62 static inline void debug_fence_destroy(struct i915_sw_fence *fence)
64 debug_object_destroy(fence, &i915_sw_fence_debug_descr);
67 static inline void debug_fence_free(struct i915_sw_fence *fence)
69 debug_object_free(fence, &i915_sw_fence_debug_descr);
70 smp_wmb(); /* flush the change in state before reallocation */
73 static inline void debug_fence_assert(struct i915_sw_fence *fence)
75 debug_object_assert_init(fence, &i915_sw_fence_debug_descr);
80 static inline void debug_fence_init(struct i915_sw_fence *fence)
84 static inline void debug_fence_init_onstack(struct i915_sw_fence *fence)
88 static inline void debug_fence_activate(struct i915_sw_fence *fence)
92 static inline void debug_fence_set_state(struct i915_sw_fence *fence,
97 static inline void debug_fence_deactivate(struct i915_sw_fence *fence)
101 static inline void debug_fence_destroy(struct i915_sw_fence *fence)
105 static inline void debug_fence_free(struct i915_sw_fence *fence)
109 static inline void debug_fence_assert(struct i915_sw_fence *fence)
115 static int __i915_sw_fence_notify(struct i915_sw_fence *fence,
116 enum i915_sw_fence_notify state)
118 i915_sw_fence_notify_t fn;
120 fn = (i915_sw_fence_notify_t)(fence->flags & I915_SW_FENCE_MASK);
121 return fn(fence, state);
124 #ifdef CONFIG_DRM_I915_SW_FENCE_DEBUG_OBJECTS
125 void i915_sw_fence_fini(struct i915_sw_fence *fence)
127 debug_fence_free(fence);
131 static void __i915_sw_fence_wake_up_all(struct i915_sw_fence *fence,
132 struct list_head *continuation)
134 wait_queue_head_t *x = &fence->wait;
135 wait_queue_entry_t *pos, *next;
138 debug_fence_deactivate(fence);
139 atomic_set_release(&fence->pending, -1); /* 0 -> -1 [done] */
142 * To prevent unbounded recursion as we traverse the graph of
143 * i915_sw_fences, we move the entry list from this, the next ready
144 * fence, to the tail of the original fence's entry list
145 * (and so added to the list to be woken).
148 spin_lock_irqsave_nested(&x->lock, flags, 1 + !!continuation);
150 list_for_each_entry_safe(pos, next, &x->head, entry) {
151 if (pos->func == autoremove_wake_function)
152 pos->func(pos, TASK_NORMAL, 0, continuation);
154 list_move_tail(&pos->entry, continuation);
160 list_for_each_entry_safe(pos, next, &x->head, entry)
161 pos->func(pos, TASK_NORMAL, 0, &extra);
163 if (list_empty(&extra))
166 list_splice_tail_init(&extra, &x->head);
169 spin_unlock_irqrestore(&x->lock, flags);
171 debug_fence_assert(fence);
174 static void __i915_sw_fence_complete(struct i915_sw_fence *fence,
175 struct list_head *continuation)
177 debug_fence_assert(fence);
179 if (!atomic_dec_and_test(&fence->pending))
182 debug_fence_set_state(fence, DEBUG_FENCE_IDLE, DEBUG_FENCE_NOTIFY);
184 if (__i915_sw_fence_notify(fence, FENCE_COMPLETE) != NOTIFY_DONE)
187 debug_fence_set_state(fence, DEBUG_FENCE_NOTIFY, DEBUG_FENCE_IDLE);
189 __i915_sw_fence_wake_up_all(fence, continuation);
191 debug_fence_destroy(fence);
192 __i915_sw_fence_notify(fence, FENCE_FREE);
195 static void i915_sw_fence_complete(struct i915_sw_fence *fence)
197 debug_fence_assert(fence);
199 if (WARN_ON(i915_sw_fence_done(fence)))
202 __i915_sw_fence_complete(fence, NULL);
205 static void i915_sw_fence_await(struct i915_sw_fence *fence)
207 debug_fence_assert(fence);
208 WARN_ON(atomic_inc_return(&fence->pending) <= 1);
211 void __i915_sw_fence_init(struct i915_sw_fence *fence,
212 i915_sw_fence_notify_t fn,
214 struct lock_class_key *key)
216 BUG_ON(!fn || (unsigned long)fn & ~I915_SW_FENCE_MASK);
218 debug_fence_init(fence);
220 __init_waitqueue_head(&fence->wait, name, key);
221 atomic_set(&fence->pending, 1);
222 fence->flags = (unsigned long)fn;
225 void i915_sw_fence_commit(struct i915_sw_fence *fence)
227 debug_fence_activate(fence);
228 i915_sw_fence_complete(fence);
231 static int i915_sw_fence_wake(wait_queue_entry_t *wq, unsigned mode, int flags, void *key)
233 list_del(&wq->entry);
234 __i915_sw_fence_complete(wq->private, key);
236 if (wq->flags & I915_SW_FENCE_FLAG_ALLOC)
241 static bool __i915_sw_fence_check_if_after(struct i915_sw_fence *fence,
242 const struct i915_sw_fence * const signaler)
244 wait_queue_entry_t *wq;
246 if (__test_and_set_bit(I915_SW_FENCE_CHECKED_BIT, &fence->flags))
249 if (fence == signaler)
252 list_for_each_entry(wq, &fence->wait.head, entry) {
253 if (wq->func != i915_sw_fence_wake)
256 if (__i915_sw_fence_check_if_after(wq->private, signaler))
263 static void __i915_sw_fence_clear_checked_bit(struct i915_sw_fence *fence)
265 wait_queue_entry_t *wq;
267 if (!__test_and_clear_bit(I915_SW_FENCE_CHECKED_BIT, &fence->flags))
270 list_for_each_entry(wq, &fence->wait.head, entry) {
271 if (wq->func != i915_sw_fence_wake)
274 __i915_sw_fence_clear_checked_bit(wq->private);
278 static bool i915_sw_fence_check_if_after(struct i915_sw_fence *fence,
279 const struct i915_sw_fence * const signaler)
284 if (!IS_ENABLED(CONFIG_DRM_I915_SW_FENCE_CHECK_DAG))
287 spin_lock_irqsave(&i915_sw_fence_lock, flags);
288 err = __i915_sw_fence_check_if_after(fence, signaler);
289 __i915_sw_fence_clear_checked_bit(fence);
290 spin_unlock_irqrestore(&i915_sw_fence_lock, flags);
295 static int __i915_sw_fence_await_sw_fence(struct i915_sw_fence *fence,
296 struct i915_sw_fence *signaler,
297 wait_queue_entry_t *wq, gfp_t gfp)
302 debug_fence_assert(fence);
303 might_sleep_if(gfpflags_allow_blocking(gfp));
305 if (i915_sw_fence_done(signaler))
308 debug_fence_assert(signaler);
310 /* The dependency graph must be acyclic. */
311 if (unlikely(i915_sw_fence_check_if_after(fence, signaler)))
316 wq = kmalloc(sizeof(*wq), gfp);
318 if (!gfpflags_allow_blocking(gfp))
321 i915_sw_fence_wait(signaler);
325 pending |= I915_SW_FENCE_FLAG_ALLOC;
328 INIT_LIST_HEAD(&wq->entry);
330 wq->func = i915_sw_fence_wake;
333 i915_sw_fence_await(fence);
335 spin_lock_irqsave(&signaler->wait.lock, flags);
336 if (likely(!i915_sw_fence_done(signaler))) {
337 __add_wait_queue_entry_tail(&signaler->wait, wq);
340 i915_sw_fence_wake(wq, 0, 0, NULL);
343 spin_unlock_irqrestore(&signaler->wait.lock, flags);
348 int i915_sw_fence_await_sw_fence(struct i915_sw_fence *fence,
349 struct i915_sw_fence *signaler,
350 wait_queue_entry_t *wq)
352 return __i915_sw_fence_await_sw_fence(fence, signaler, wq, 0);
355 int i915_sw_fence_await_sw_fence_gfp(struct i915_sw_fence *fence,
356 struct i915_sw_fence *signaler,
359 return __i915_sw_fence_await_sw_fence(fence, signaler, NULL, gfp);
362 struct i915_sw_dma_fence_cb {
363 struct dma_fence_cb base;
364 struct i915_sw_fence *fence;
367 struct i915_sw_dma_fence_cb_timer {
368 struct i915_sw_dma_fence_cb base;
369 struct dma_fence *dma;
370 struct timer_list timer;
371 struct irq_work work;
375 static void dma_i915_sw_fence_wake(struct dma_fence *dma,
376 struct dma_fence_cb *data)
378 struct i915_sw_dma_fence_cb *cb = container_of(data, typeof(*cb), base);
380 i915_sw_fence_complete(cb->fence);
384 static void timer_i915_sw_fence_wake(struct timer_list *t)
386 struct i915_sw_dma_fence_cb_timer *cb = from_timer(cb, t, timer);
387 struct i915_sw_fence *fence;
389 fence = xchg(&cb->base.fence, NULL);
393 pr_notice("Asynchronous wait on fence %s:%s:%x timed out (hint:%pS)\n",
394 cb->dma->ops->get_driver_name(cb->dma),
395 cb->dma->ops->get_timeline_name(cb->dma),
397 i915_sw_fence_debug_hint(fence));
399 i915_sw_fence_complete(fence);
402 static void dma_i915_sw_fence_wake_timer(struct dma_fence *dma,
403 struct dma_fence_cb *data)
405 struct i915_sw_dma_fence_cb_timer *cb =
406 container_of(data, typeof(*cb), base.base);
407 struct i915_sw_fence *fence;
409 fence = xchg(&cb->base.fence, NULL);
411 i915_sw_fence_complete(fence);
413 irq_work_queue(&cb->work);
416 static void irq_i915_sw_fence_work(struct irq_work *wrk)
418 struct i915_sw_dma_fence_cb_timer *cb =
419 container_of(wrk, typeof(*cb), work);
421 del_timer_sync(&cb->timer);
422 dma_fence_put(cb->dma);
427 int i915_sw_fence_await_dma_fence(struct i915_sw_fence *fence,
428 struct dma_fence *dma,
429 unsigned long timeout,
432 struct i915_sw_dma_fence_cb *cb;
433 dma_fence_func_t func;
436 debug_fence_assert(fence);
437 might_sleep_if(gfpflags_allow_blocking(gfp));
439 if (dma_fence_is_signaled(dma))
442 cb = kmalloc(timeout ?
443 sizeof(struct i915_sw_dma_fence_cb_timer) :
444 sizeof(struct i915_sw_dma_fence_cb),
447 if (!gfpflags_allow_blocking(gfp))
450 return dma_fence_wait(dma, false);
454 i915_sw_fence_await(fence);
456 func = dma_i915_sw_fence_wake;
458 struct i915_sw_dma_fence_cb_timer *timer =
459 container_of(cb, typeof(*timer), base);
461 timer->dma = dma_fence_get(dma);
462 init_irq_work(&timer->work, irq_i915_sw_fence_work);
464 timer_setup(&timer->timer,
465 timer_i915_sw_fence_wake, TIMER_IRQSAFE);
466 mod_timer(&timer->timer, round_jiffies_up(jiffies + timeout));
468 func = dma_i915_sw_fence_wake_timer;
471 ret = dma_fence_add_callback(dma, &cb->base, func);
475 func(dma, &cb->base);
476 if (ret == -ENOENT) /* fence already signaled */
483 int i915_sw_fence_await_reservation(struct i915_sw_fence *fence,
484 struct reservation_object *resv,
485 const struct dma_fence_ops *exclude,
487 unsigned long timeout,
490 struct dma_fence *excl;
491 int ret = 0, pending;
493 debug_fence_assert(fence);
494 might_sleep_if(gfpflags_allow_blocking(gfp));
497 struct dma_fence **shared;
498 unsigned int count, i;
500 ret = reservation_object_get_fences_rcu(resv,
501 &excl, &count, &shared);
505 for (i = 0; i < count; i++) {
506 if (shared[i]->ops == exclude)
509 pending = i915_sw_fence_await_dma_fence(fence,
521 for (i = 0; i < count; i++)
522 dma_fence_put(shared[i]);
525 excl = reservation_object_get_excl_rcu(resv);
528 if (ret >= 0 && excl && excl->ops != exclude) {
529 pending = i915_sw_fence_await_dma_fence(fence,
544 #if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)
545 #include "selftests/lib_sw_fence.c"
546 #include "selftests/i915_sw_fence.c"