Linux Audio

Check our new training course

Loading...
Note: File does not exist in v4.6.
  1/*
  2 * SPDX-License-Identifier: MIT
  3 *
  4 * (C) Copyright 2016 Intel Corporation
  5 */
  6
  7#include <linux/slab.h>
  8#include <linux/dma-fence.h>
  9#include <linux/irq_work.h>
 10#include <linux/dma-resv.h>
 11
 12#include "i915_sw_fence.h"
 13#include "i915_selftest.h"
 14
 15#if IS_ENABLED(CONFIG_DRM_I915_DEBUG)
 16#define I915_SW_FENCE_BUG_ON(expr) BUG_ON(expr)
 17#else
 18#define I915_SW_FENCE_BUG_ON(expr) BUILD_BUG_ON_INVALID(expr)
 19#endif
 20
 21static DEFINE_SPINLOCK(i915_sw_fence_lock);
 22
 23#define WQ_FLAG_BITS \
 24	BITS_PER_TYPE(typeof_member(struct wait_queue_entry, flags))
 25
 26/* after WQ_FLAG_* for safety */
 27#define I915_SW_FENCE_FLAG_FENCE BIT(WQ_FLAG_BITS - 1)
 28#define I915_SW_FENCE_FLAG_ALLOC BIT(WQ_FLAG_BITS - 2)
 29
 30enum {
 31	DEBUG_FENCE_IDLE = 0,
 32	DEBUG_FENCE_NOTIFY,
 33};
 34
 35static void *i915_sw_fence_debug_hint(void *addr)
 36{
 37	return (void *)(((struct i915_sw_fence *)addr)->flags & I915_SW_FENCE_MASK);
 38}
 39
 40#ifdef CONFIG_DRM_I915_SW_FENCE_DEBUG_OBJECTS
 41
 42static const struct debug_obj_descr i915_sw_fence_debug_descr = {
 43	.name = "i915_sw_fence",
 44	.debug_hint = i915_sw_fence_debug_hint,
 45};
 46
 47static inline void debug_fence_init(struct i915_sw_fence *fence)
 48{
 49	debug_object_init(fence, &i915_sw_fence_debug_descr);
 50}
 51
 52static inline void debug_fence_init_onstack(struct i915_sw_fence *fence)
 53{
 54	debug_object_init_on_stack(fence, &i915_sw_fence_debug_descr);
 55}
 56
 57static inline void debug_fence_activate(struct i915_sw_fence *fence)
 58{
 59	debug_object_activate(fence, &i915_sw_fence_debug_descr);
 60}
 61
 62static inline void debug_fence_set_state(struct i915_sw_fence *fence,
 63					 int old, int new)
 64{
 65	debug_object_active_state(fence, &i915_sw_fence_debug_descr, old, new);
 66}
 67
 68static inline void debug_fence_deactivate(struct i915_sw_fence *fence)
 69{
 70	debug_object_deactivate(fence, &i915_sw_fence_debug_descr);
 71}
 72
 73static inline void debug_fence_destroy(struct i915_sw_fence *fence)
 74{
 75	debug_object_destroy(fence, &i915_sw_fence_debug_descr);
 76}
 77
 78static inline void debug_fence_free(struct i915_sw_fence *fence)
 79{
 80	debug_object_free(fence, &i915_sw_fence_debug_descr);
 81	smp_wmb(); /* flush the change in state before reallocation */
 82}
 83
 84static inline void debug_fence_assert(struct i915_sw_fence *fence)
 85{
 86	debug_object_assert_init(fence, &i915_sw_fence_debug_descr);
 87}
 88
 89#else
 90
 91static inline void debug_fence_init(struct i915_sw_fence *fence)
 92{
 93}
 94
 95static inline void debug_fence_init_onstack(struct i915_sw_fence *fence)
 96{
 97}
 98
 99static inline void debug_fence_activate(struct i915_sw_fence *fence)
100{
101}
102
103static inline void debug_fence_set_state(struct i915_sw_fence *fence,
104					 int old, int new)
105{
106}
107
108static inline void debug_fence_deactivate(struct i915_sw_fence *fence)
109{
110}
111
112static inline void debug_fence_destroy(struct i915_sw_fence *fence)
113{
114}
115
116static inline void debug_fence_free(struct i915_sw_fence *fence)
117{
118}
119
120static inline void debug_fence_assert(struct i915_sw_fence *fence)
121{
122}
123
124#endif
125
126static int __i915_sw_fence_notify(struct i915_sw_fence *fence,
127				  enum i915_sw_fence_notify state)
128{
129	i915_sw_fence_notify_t fn;
130
131	fn = (i915_sw_fence_notify_t)(fence->flags & I915_SW_FENCE_MASK);
132	return fn(fence, state);
133}
134
135#ifdef CONFIG_DRM_I915_SW_FENCE_DEBUG_OBJECTS
136void i915_sw_fence_fini(struct i915_sw_fence *fence)
137{
138	debug_fence_free(fence);
139}
140#endif
141
142static void __i915_sw_fence_wake_up_all(struct i915_sw_fence *fence,
143					struct list_head *continuation)
144{
145	wait_queue_head_t *x = &fence->wait;
146	wait_queue_entry_t *pos, *next;
147	unsigned long flags;
148
149	debug_fence_deactivate(fence);
150	atomic_set_release(&fence->pending, -1); /* 0 -> -1 [done] */
151
152	/*
153	 * To prevent unbounded recursion as we traverse the graph of
154	 * i915_sw_fences, we move the entry list from this, the next ready
155	 * fence, to the tail of the original fence's entry list
156	 * (and so added to the list to be woken).
157	 */
158
159	spin_lock_irqsave_nested(&x->lock, flags, 1 + !!continuation);
160	if (continuation) {
161		list_for_each_entry_safe(pos, next, &x->head, entry) {
162			if (pos->flags & I915_SW_FENCE_FLAG_FENCE)
163				list_move_tail(&pos->entry, continuation);
164			else
165				pos->func(pos, TASK_NORMAL, 0, continuation);
166		}
167	} else {
168		LIST_HEAD(extra);
169
170		do {
171			list_for_each_entry_safe(pos, next, &x->head, entry) {
172				int wake_flags;
173
174				wake_flags = 0;
175				if (pos->flags & I915_SW_FENCE_FLAG_FENCE)
176					wake_flags = fence->error;
177
178				pos->func(pos, TASK_NORMAL, wake_flags, &extra);
179			}
180
181			if (list_empty(&extra))
182				break;
183
184			list_splice_tail_init(&extra, &x->head);
185		} while (1);
186	}
187	spin_unlock_irqrestore(&x->lock, flags);
188
189	debug_fence_assert(fence);
190}
191
192static void __i915_sw_fence_complete(struct i915_sw_fence *fence,
193				     struct list_head *continuation)
194{
195	debug_fence_assert(fence);
196
197	if (!atomic_dec_and_test(&fence->pending))
198		return;
199
200	debug_fence_set_state(fence, DEBUG_FENCE_IDLE, DEBUG_FENCE_NOTIFY);
201
202	if (__i915_sw_fence_notify(fence, FENCE_COMPLETE) != NOTIFY_DONE)
203		return;
204
205	debug_fence_set_state(fence, DEBUG_FENCE_NOTIFY, DEBUG_FENCE_IDLE);
206
207	__i915_sw_fence_wake_up_all(fence, continuation);
208
209	debug_fence_destroy(fence);
210	__i915_sw_fence_notify(fence, FENCE_FREE);
211}
212
213void i915_sw_fence_complete(struct i915_sw_fence *fence)
214{
215	debug_fence_assert(fence);
216
217	if (WARN_ON(i915_sw_fence_done(fence)))
218		return;
219
220	__i915_sw_fence_complete(fence, NULL);
221}
222
223bool i915_sw_fence_await(struct i915_sw_fence *fence)
224{
225	int pending;
226
227	/*
228	 * It is only safe to add a new await to the fence while it has
229	 * not yet been signaled (i.e. there are still existing signalers).
230	 */
231	pending = atomic_read(&fence->pending);
232	do {
233		if (pending < 1)
234			return false;
235	} while (!atomic_try_cmpxchg(&fence->pending, &pending, pending + 1));
236
237	return true;
238}
239
240void __i915_sw_fence_init(struct i915_sw_fence *fence,
241			  i915_sw_fence_notify_t fn,
242			  const char *name,
243			  struct lock_class_key *key)
244{
245	BUG_ON(!fn || (unsigned long)fn & ~I915_SW_FENCE_MASK);
246
247	__init_waitqueue_head(&fence->wait, name, key);
248	fence->flags = (unsigned long)fn;
249
250	i915_sw_fence_reinit(fence);
251}
252
253void i915_sw_fence_reinit(struct i915_sw_fence *fence)
254{
255	debug_fence_init(fence);
256
257	atomic_set(&fence->pending, 1);
258	fence->error = 0;
259
260	I915_SW_FENCE_BUG_ON(!fence->flags);
261	I915_SW_FENCE_BUG_ON(!list_empty(&fence->wait.head));
262}
263
264void i915_sw_fence_commit(struct i915_sw_fence *fence)
265{
266	debug_fence_activate(fence);
267	i915_sw_fence_complete(fence);
268}
269
270static int i915_sw_fence_wake(wait_queue_entry_t *wq, unsigned mode, int flags, void *key)
271{
272	i915_sw_fence_set_error_once(wq->private, flags);
273
274	list_del(&wq->entry);
275	__i915_sw_fence_complete(wq->private, key);
276
277	if (wq->flags & I915_SW_FENCE_FLAG_ALLOC)
278		kfree(wq);
279	return 0;
280}
281
282static bool __i915_sw_fence_check_if_after(struct i915_sw_fence *fence,
283				    const struct i915_sw_fence * const signaler)
284{
285	wait_queue_entry_t *wq;
286
287	if (__test_and_set_bit(I915_SW_FENCE_CHECKED_BIT, &fence->flags))
288		return false;
289
290	if (fence == signaler)
291		return true;
292
293	list_for_each_entry(wq, &fence->wait.head, entry) {
294		if (wq->func != i915_sw_fence_wake)
295			continue;
296
297		if (__i915_sw_fence_check_if_after(wq->private, signaler))
298			return true;
299	}
300
301	return false;
302}
303
304static void __i915_sw_fence_clear_checked_bit(struct i915_sw_fence *fence)
305{
306	wait_queue_entry_t *wq;
307
308	if (!__test_and_clear_bit(I915_SW_FENCE_CHECKED_BIT, &fence->flags))
309		return;
310
311	list_for_each_entry(wq, &fence->wait.head, entry) {
312		if (wq->func != i915_sw_fence_wake)
313			continue;
314
315		__i915_sw_fence_clear_checked_bit(wq->private);
316	}
317}
318
319static bool i915_sw_fence_check_if_after(struct i915_sw_fence *fence,
320				  const struct i915_sw_fence * const signaler)
321{
322	unsigned long flags;
323	bool err;
324
325	if (!IS_ENABLED(CONFIG_DRM_I915_SW_FENCE_CHECK_DAG))
326		return false;
327
328	spin_lock_irqsave(&i915_sw_fence_lock, flags);
329	err = __i915_sw_fence_check_if_after(fence, signaler);
330	__i915_sw_fence_clear_checked_bit(fence);
331	spin_unlock_irqrestore(&i915_sw_fence_lock, flags);
332
333	return err;
334}
335
336static int __i915_sw_fence_await_sw_fence(struct i915_sw_fence *fence,
337					  struct i915_sw_fence *signaler,
338					  wait_queue_entry_t *wq, gfp_t gfp)
339{
340	unsigned int pending;
341	unsigned long flags;
342
343	debug_fence_assert(fence);
344	might_sleep_if(gfpflags_allow_blocking(gfp));
345
346	if (i915_sw_fence_done(signaler)) {
347		i915_sw_fence_set_error_once(fence, signaler->error);
348		return 0;
349	}
350
351	debug_fence_assert(signaler);
352
353	/* The dependency graph must be acyclic. */
354	if (unlikely(i915_sw_fence_check_if_after(fence, signaler)))
355		return -EINVAL;
356
357	pending = I915_SW_FENCE_FLAG_FENCE;
358	if (!wq) {
359		wq = kmalloc(sizeof(*wq), gfp);
360		if (!wq) {
361			if (!gfpflags_allow_blocking(gfp))
362				return -ENOMEM;
363
364			i915_sw_fence_wait(signaler);
365			i915_sw_fence_set_error_once(fence, signaler->error);
366			return 0;
367		}
368
369		pending |= I915_SW_FENCE_FLAG_ALLOC;
370	}
371
372	INIT_LIST_HEAD(&wq->entry);
373	wq->flags = pending;
374	wq->func = i915_sw_fence_wake;
375	wq->private = fence;
376
377	i915_sw_fence_await(fence);
378
379	spin_lock_irqsave(&signaler->wait.lock, flags);
380	if (likely(!i915_sw_fence_done(signaler))) {
381		__add_wait_queue_entry_tail(&signaler->wait, wq);
382		pending = 1;
383	} else {
384		i915_sw_fence_wake(wq, 0, signaler->error, NULL);
385		pending = 0;
386	}
387	spin_unlock_irqrestore(&signaler->wait.lock, flags);
388
389	return pending;
390}
391
392int i915_sw_fence_await_sw_fence(struct i915_sw_fence *fence,
393				 struct i915_sw_fence *signaler,
394				 wait_queue_entry_t *wq)
395{
396	return __i915_sw_fence_await_sw_fence(fence, signaler, wq, 0);
397}
398
399int i915_sw_fence_await_sw_fence_gfp(struct i915_sw_fence *fence,
400				     struct i915_sw_fence *signaler,
401				     gfp_t gfp)
402{
403	return __i915_sw_fence_await_sw_fence(fence, signaler, NULL, gfp);
404}
405
406struct i915_sw_dma_fence_cb_timer {
407	struct i915_sw_dma_fence_cb base;
408	struct dma_fence *dma;
409	struct timer_list timer;
410	struct irq_work work;
411	struct rcu_head rcu;
412};
413
414static void dma_i915_sw_fence_wake(struct dma_fence *dma,
415				   struct dma_fence_cb *data)
416{
417	struct i915_sw_dma_fence_cb *cb = container_of(data, typeof(*cb), base);
418
419	i915_sw_fence_set_error_once(cb->fence, dma->error);
420	i915_sw_fence_complete(cb->fence);
421	kfree(cb);
422}
423
424static void timer_i915_sw_fence_wake(struct timer_list *t)
425{
426	struct i915_sw_dma_fence_cb_timer *cb = from_timer(cb, t, timer);
427	struct i915_sw_fence *fence;
428
429	fence = xchg(&cb->base.fence, NULL);
430	if (!fence)
431		return;
432
433	pr_notice("Asynchronous wait on fence %s:%s:%llx timed out (hint:%ps)\n",
434		  cb->dma->ops->get_driver_name(cb->dma),
435		  cb->dma->ops->get_timeline_name(cb->dma),
436		  cb->dma->seqno,
437		  i915_sw_fence_debug_hint(fence));
438
439	i915_sw_fence_set_error_once(fence, -ETIMEDOUT);
440	i915_sw_fence_complete(fence);
441}
442
443static void dma_i915_sw_fence_wake_timer(struct dma_fence *dma,
444					 struct dma_fence_cb *data)
445{
446	struct i915_sw_dma_fence_cb_timer *cb =
447		container_of(data, typeof(*cb), base.base);
448	struct i915_sw_fence *fence;
449
450	fence = xchg(&cb->base.fence, NULL);
451	if (fence) {
452		i915_sw_fence_set_error_once(fence, dma->error);
453		i915_sw_fence_complete(fence);
454	}
455
456	irq_work_queue(&cb->work);
457}
458
459static void irq_i915_sw_fence_work(struct irq_work *wrk)
460{
461	struct i915_sw_dma_fence_cb_timer *cb =
462		container_of(wrk, typeof(*cb), work);
463
464	del_timer_sync(&cb->timer);
465	dma_fence_put(cb->dma);
466
467	kfree_rcu(cb, rcu);
468}
469
470int i915_sw_fence_await_dma_fence(struct i915_sw_fence *fence,
471				  struct dma_fence *dma,
472				  unsigned long timeout,
473				  gfp_t gfp)
474{
475	struct i915_sw_dma_fence_cb *cb;
476	dma_fence_func_t func;
477	int ret;
478
479	debug_fence_assert(fence);
480	might_sleep_if(gfpflags_allow_blocking(gfp));
481
482	if (dma_fence_is_signaled(dma)) {
483		i915_sw_fence_set_error_once(fence, dma->error);
484		return 0;
485	}
486
487	cb = kmalloc(timeout ?
488		     sizeof(struct i915_sw_dma_fence_cb_timer) :
489		     sizeof(struct i915_sw_dma_fence_cb),
490		     gfp);
491	if (!cb) {
492		if (!gfpflags_allow_blocking(gfp))
493			return -ENOMEM;
494
495		ret = dma_fence_wait(dma, false);
496		if (ret)
497			return ret;
498
499		i915_sw_fence_set_error_once(fence, dma->error);
500		return 0;
501	}
502
503	cb->fence = fence;
504	i915_sw_fence_await(fence);
505
506	func = dma_i915_sw_fence_wake;
507	if (timeout) {
508		struct i915_sw_dma_fence_cb_timer *timer =
509			container_of(cb, typeof(*timer), base);
510
511		timer->dma = dma_fence_get(dma);
512		init_irq_work(&timer->work, irq_i915_sw_fence_work);
513
514		timer_setup(&timer->timer,
515			    timer_i915_sw_fence_wake, TIMER_IRQSAFE);
516		mod_timer(&timer->timer, round_jiffies_up(jiffies + timeout));
517
518		func = dma_i915_sw_fence_wake_timer;
519	}
520
521	ret = dma_fence_add_callback(dma, &cb->base, func);
522	if (ret == 0) {
523		ret = 1;
524	} else {
525		func(dma, &cb->base);
526		if (ret == -ENOENT) /* fence already signaled */
527			ret = 0;
528	}
529
530	return ret;
531}
532
533static void __dma_i915_sw_fence_wake(struct dma_fence *dma,
534				     struct dma_fence_cb *data)
535{
536	struct i915_sw_dma_fence_cb *cb = container_of(data, typeof(*cb), base);
537
538	i915_sw_fence_set_error_once(cb->fence, dma->error);
539	i915_sw_fence_complete(cb->fence);
540}
541
542int __i915_sw_fence_await_dma_fence(struct i915_sw_fence *fence,
543				    struct dma_fence *dma,
544				    struct i915_sw_dma_fence_cb *cb)
545{
546	int ret;
547
548	debug_fence_assert(fence);
549
550	if (dma_fence_is_signaled(dma)) {
551		i915_sw_fence_set_error_once(fence, dma->error);
552		return 0;
553	}
554
555	cb->fence = fence;
556	i915_sw_fence_await(fence);
557
558	ret = 1;
559	if (dma_fence_add_callback(dma, &cb->base, __dma_i915_sw_fence_wake)) {
560		/* fence already signaled */
561		__dma_i915_sw_fence_wake(dma, &cb->base);
562		ret = 0;
563	}
564
565	return ret;
566}
567
568int i915_sw_fence_await_reservation(struct i915_sw_fence *fence,
569				    struct dma_resv *resv,
570				    const struct dma_fence_ops *exclude,
571				    bool write,
572				    unsigned long timeout,
573				    gfp_t gfp)
574{
575	struct dma_fence *excl;
576	int ret = 0, pending;
577
578	debug_fence_assert(fence);
579	might_sleep_if(gfpflags_allow_blocking(gfp));
580
581	if (write) {
582		struct dma_fence **shared;
583		unsigned int count, i;
584
585		ret = dma_resv_get_fences(resv, &excl, &count, &shared);
586		if (ret)
587			return ret;
588
589		for (i = 0; i < count; i++) {
590			if (shared[i]->ops == exclude)
591				continue;
592
593			pending = i915_sw_fence_await_dma_fence(fence,
594								shared[i],
595								timeout,
596								gfp);
597			if (pending < 0) {
598				ret = pending;
599				break;
600			}
601
602			ret |= pending;
603		}
604
605		for (i = 0; i < count; i++)
606			dma_fence_put(shared[i]);
607		kfree(shared);
608	} else {
609		excl = dma_resv_get_excl_unlocked(resv);
610	}
611
612	if (ret >= 0 && excl && excl->ops != exclude) {
613		pending = i915_sw_fence_await_dma_fence(fence,
614							excl,
615							timeout,
616							gfp);
617		if (pending < 0)
618			ret = pending;
619		else
620			ret |= pending;
621	}
622
623	dma_fence_put(excl);
624
625	return ret;
626}
627
628#if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)
629#include "selftests/lib_sw_fence.c"
630#include "selftests/i915_sw_fence.c"
631#endif