1/*
  2 * (C) Copyright 2016 Intel Corporation
  3 *
  4 * This program is free software; you can redistribute it and/or
  5 * modify it under the terms of the GNU General Public License
  6 * as published by the Free Software Foundation; version 2
  7 * of the License.
  8 */
  9
 10#include <linux/slab.h>
 11#include <linux/dma-fence.h>
 12#include <linux/reservation.h>
 13
 14#include "i915_sw_fence.h"
 15
 16#define I915_SW_FENCE_FLAG_ALLOC BIT(3) /* after WQ_FLAG_* for safety */
 17
 18static DEFINE_SPINLOCK(i915_sw_fence_lock);
 19
 20static int __i915_sw_fence_notify(struct i915_sw_fence *fence,
 21				  enum i915_sw_fence_notify state)
 22{
 23	i915_sw_fence_notify_t fn;
 24
 25	fn = (i915_sw_fence_notify_t)(fence->flags & I915_SW_FENCE_MASK);
 26	return fn(fence, state);
 27}
 28
 29static void i915_sw_fence_free(struct kref *kref)
 30{
 31	struct i915_sw_fence *fence = container_of(kref, typeof(*fence), kref);
 32
 33	WARN_ON(atomic_read(&fence->pending) > 0);
 34
 35	if (fence->flags & I915_SW_FENCE_MASK)
 36		__i915_sw_fence_notify(fence, FENCE_FREE);
 37	else
 38		kfree(fence);
 39}
 40
 41static void i915_sw_fence_put(struct i915_sw_fence *fence)
 42{
 43	kref_put(&fence->kref, i915_sw_fence_free);
 44}
 45
 46static struct i915_sw_fence *i915_sw_fence_get(struct i915_sw_fence *fence)
 47{
 48	kref_get(&fence->kref);
 49	return fence;
 50}
 51
 52static void __i915_sw_fence_wake_up_all(struct i915_sw_fence *fence,
 53					struct list_head *continuation)
 54{
 55	wait_queue_head_t *x = &fence->wait;
 56	wait_queue_t *pos, *next;
 57	unsigned long flags;
 58
 59	atomic_set_release(&fence->pending, -1); /* 0 -> -1 [done] */
 60
 61	/*
 62	 * To prevent unbounded recursion as we traverse the graph of
 63	 * i915_sw_fences, we move the task_list from this, the next ready
 64	 * fence, to the tail of the original fence's task_list
 65	 * (and so added to the list to be woken).
 66	 */
 67
 68	spin_lock_irqsave_nested(&x->lock, flags, 1 + !!continuation);
 69	if (continuation) {
 70		list_for_each_entry_safe(pos, next, &x->task_list, task_list) {
 71			if (pos->func == autoremove_wake_function)
 72				pos->func(pos, TASK_NORMAL, 0, continuation);
 73			else
 74				list_move_tail(&pos->task_list, continuation);
 75		}
 76	} else {
 77		LIST_HEAD(extra);
 78
 79		do {
 80			list_for_each_entry_safe(pos, next,
 81						 &x->task_list, task_list)
 82				pos->func(pos, TASK_NORMAL, 0, &extra);
 83
 84			if (list_empty(&extra))
 85				break;
 86
 87			list_splice_tail_init(&extra, &x->task_list);
 88		} while (1);
 89	}
 90	spin_unlock_irqrestore(&x->lock, flags);
 91}
 92
 93static void __i915_sw_fence_complete(struct i915_sw_fence *fence,
 94				     struct list_head *continuation)
 95{
 96	if (!atomic_dec_and_test(&fence->pending))
 97		return;
 98
 99	if (fence->flags & I915_SW_FENCE_MASK &&
100	    __i915_sw_fence_notify(fence, FENCE_COMPLETE) != NOTIFY_DONE)
101		return;
102
103	__i915_sw_fence_wake_up_all(fence, continuation);
104}
105
106static void i915_sw_fence_complete(struct i915_sw_fence *fence)
107{
108	if (WARN_ON(i915_sw_fence_done(fence)))
109		return;
110
111	__i915_sw_fence_complete(fence, NULL);
112}
113
114static void i915_sw_fence_await(struct i915_sw_fence *fence)
115{
116	WARN_ON(atomic_inc_return(&fence->pending) <= 1);
117}
118
119void __i915_sw_fence_init(struct i915_sw_fence *fence,
120			  i915_sw_fence_notify_t fn,
121			  const char *name,
122			  struct lock_class_key *key)
123{
124	BUG_ON((unsigned long)fn & ~I915_SW_FENCE_MASK);
125
126	__init_waitqueue_head(&fence->wait, name, key);
127	kref_init(&fence->kref);
128	atomic_set(&fence->pending, 1);
129	fence->flags = (unsigned long)fn;
130}
131
132void i915_sw_fence_commit(struct i915_sw_fence *fence)
133{
134	i915_sw_fence_complete(fence);
135	i915_sw_fence_put(fence);
136}
137
138static int i915_sw_fence_wake(wait_queue_t *wq, unsigned mode, int flags, void *key)
139{
140	list_del(&wq->task_list);
141	__i915_sw_fence_complete(wq->private, key);
142	i915_sw_fence_put(wq->private);
143	if (wq->flags & I915_SW_FENCE_FLAG_ALLOC)
144		kfree(wq);
145	return 0;
146}
147
148static bool __i915_sw_fence_check_if_after(struct i915_sw_fence *fence,
149				    const struct i915_sw_fence * const signaler)
150{
151	wait_queue_t *wq;
152
153	if (__test_and_set_bit(I915_SW_FENCE_CHECKED_BIT, &fence->flags))
154		return false;
155
156	if (fence == signaler)
157		return true;
158
159	list_for_each_entry(wq, &fence->wait.task_list, task_list) {
160		if (wq->func != i915_sw_fence_wake)
161			continue;
162
163		if (__i915_sw_fence_check_if_after(wq->private, signaler))
164			return true;
165	}
166
167	return false;
168}
169
170static void __i915_sw_fence_clear_checked_bit(struct i915_sw_fence *fence)
171{
172	wait_queue_t *wq;
173
174	if (!__test_and_clear_bit(I915_SW_FENCE_CHECKED_BIT, &fence->flags))
175		return;
176
177	list_for_each_entry(wq, &fence->wait.task_list, task_list) {
178		if (wq->func != i915_sw_fence_wake)
179			continue;
180
181		__i915_sw_fence_clear_checked_bit(wq->private);
182	}
183}
184
185static bool i915_sw_fence_check_if_after(struct i915_sw_fence *fence,
186				  const struct i915_sw_fence * const signaler)
187{
188	unsigned long flags;
189	bool err;
190
191	if (!IS_ENABLED(CONFIG_I915_SW_FENCE_CHECK_DAG))
192		return false;
193
194	spin_lock_irqsave(&i915_sw_fence_lock, flags);
195	err = __i915_sw_fence_check_if_after(fence, signaler);
196	__i915_sw_fence_clear_checked_bit(fence);
197	spin_unlock_irqrestore(&i915_sw_fence_lock, flags);
198
199	return err;
200}
201
202static int __i915_sw_fence_await_sw_fence(struct i915_sw_fence *fence,
203					  struct i915_sw_fence *signaler,
204					  wait_queue_t *wq, gfp_t gfp)
205{
206	unsigned long flags;
207	int pending;
208
209	if (i915_sw_fence_done(signaler))
210		return 0;
211
212	/* The dependency graph must be acyclic. */
213	if (unlikely(i915_sw_fence_check_if_after(fence, signaler)))
214		return -EINVAL;
215
216	pending = 0;
217	if (!wq) {
218		wq = kmalloc(sizeof(*wq), gfp);
219		if (!wq) {
220			if (!gfpflags_allow_blocking(gfp))
221				return -ENOMEM;
222
223			i915_sw_fence_wait(signaler);
224			return 0;
225		}
226
227		pending |= I915_SW_FENCE_FLAG_ALLOC;
228	}
229
230	INIT_LIST_HEAD(&wq->task_list);
231	wq->flags = pending;
232	wq->func = i915_sw_fence_wake;
233	wq->private = i915_sw_fence_get(fence);
234
235	i915_sw_fence_await(fence);
236
237	spin_lock_irqsave(&signaler->wait.lock, flags);
238	if (likely(!i915_sw_fence_done(signaler))) {
239		__add_wait_queue_tail(&signaler->wait, wq);
240		pending = 1;
241	} else {
242		i915_sw_fence_wake(wq, 0, 0, NULL);
243		pending = 0;
244	}
245	spin_unlock_irqrestore(&signaler->wait.lock, flags);
246
247	return pending;
248}
249
250int i915_sw_fence_await_sw_fence(struct i915_sw_fence *fence,
251				 struct i915_sw_fence *signaler,
252				 wait_queue_t *wq)
253{
254	return __i915_sw_fence_await_sw_fence(fence, signaler, wq, 0);
255}
256
257int i915_sw_fence_await_sw_fence_gfp(struct i915_sw_fence *fence,
258				     struct i915_sw_fence *signaler,
259				     gfp_t gfp)
260{
261	return __i915_sw_fence_await_sw_fence(fence, signaler, NULL, gfp);
262}
263
264struct i915_sw_dma_fence_cb {
265	struct dma_fence_cb base;
266	struct i915_sw_fence *fence;
267	struct dma_fence *dma;
268	struct timer_list timer;
269};
270
271static void timer_i915_sw_fence_wake(unsigned long data)
272{
273	struct i915_sw_dma_fence_cb *cb = (struct i915_sw_dma_fence_cb *)data;
274
275	printk(KERN_WARNING "asynchronous wait on fence %s:%s:%x timed out\n",
276	       cb->dma->ops->get_driver_name(cb->dma),
277	       cb->dma->ops->get_timeline_name(cb->dma),
278	       cb->dma->seqno);
279	dma_fence_put(cb->dma);
280	cb->dma = NULL;
281
282	i915_sw_fence_commit(cb->fence);
283	cb->timer.function = NULL;
284}
285
286static void dma_i915_sw_fence_wake(struct dma_fence *dma,
287				   struct dma_fence_cb *data)
288{
289	struct i915_sw_dma_fence_cb *cb = container_of(data, typeof(*cb), base);
290
291	del_timer_sync(&cb->timer);
292	if (cb->timer.function)
293		i915_sw_fence_commit(cb->fence);
294	dma_fence_put(cb->dma);
295
296	kfree(cb);
297}
298
299int i915_sw_fence_await_dma_fence(struct i915_sw_fence *fence,
300				  struct dma_fence *dma,
301				  unsigned long timeout,
302				  gfp_t gfp)
303{
304	struct i915_sw_dma_fence_cb *cb;
305	int ret;
306
307	if (dma_fence_is_signaled(dma))
308		return 0;
309
310	cb = kmalloc(sizeof(*cb), gfp);
311	if (!cb) {
312		if (!gfpflags_allow_blocking(gfp))
313			return -ENOMEM;
314
315		return dma_fence_wait(dma, false);
316	}
317
318	cb->fence = i915_sw_fence_get(fence);
319	i915_sw_fence_await(fence);
320
321	cb->dma = NULL;
322	__setup_timer(&cb->timer,
323		      timer_i915_sw_fence_wake, (unsigned long)cb,
324		      TIMER_IRQSAFE);
325	if (timeout) {
326		cb->dma = dma_fence_get(dma);
327		mod_timer(&cb->timer, round_jiffies_up(jiffies + timeout));
328	}
329
330	ret = dma_fence_add_callback(dma, &cb->base, dma_i915_sw_fence_wake);
331	if (ret == 0) {
332		ret = 1;
333	} else {
334		dma_i915_sw_fence_wake(dma, &cb->base);
335		if (ret == -ENOENT) /* fence already signaled */
336			ret = 0;
337	}
338
339	return ret;
340}
341
342int i915_sw_fence_await_reservation(struct i915_sw_fence *fence,
343				    struct reservation_object *resv,
344				    const struct dma_fence_ops *exclude,
345				    bool write,
346				    unsigned long timeout,
347				    gfp_t gfp)
348{
349	struct dma_fence *excl;
350	int ret = 0, pending;
351
352	if (write) {
353		struct dma_fence **shared;
354		unsigned int count, i;
355
356		ret = reservation_object_get_fences_rcu(resv,
357							&excl, &count, &shared);
358		if (ret)
359			return ret;
360
361		for (i = 0; i < count; i++) {
362			if (shared[i]->ops == exclude)
363				continue;
364
365			pending = i915_sw_fence_await_dma_fence(fence,
366								shared[i],
367								timeout,
368								gfp);
369			if (pending < 0) {
370				ret = pending;
371				break;
372			}
373
374			ret |= pending;
375		}
376
377		for (i = 0; i < count; i++)
378			dma_fence_put(shared[i]);
379		kfree(shared);
380	} else {
381		excl = reservation_object_get_excl_rcu(resv);
382	}
383
384	if (ret >= 0 && excl && excl->ops != exclude) {
385		pending = i915_sw_fence_await_dma_fence(fence,
386							excl,
387							timeout,
388							gfp);
389		if (pending < 0)
390			ret = pending;
391		else
392			ret |= pending;
393	}
394
395	dma_fence_put(excl);
396
397	return ret;
398}