// SPDX-License-Identifier: MIT
/*
 * Copyright © 2014-2016 Intel Corporation
 */

#include <linux/jiffies.h>

#include <drm/drm_file.h>

#include "i915_drv.h"
#include "i915_file_private.h"
#include "i915_gem_context.h"
#include "i915_gem_ioctls.h"
#include "i915_gem_object.h"

/*
 * 20ms is a fairly arbitrary limit (greater than the average frame time)
 * chosen to prevent the CPU getting more than a frame ahead of the GPU
 * (when using lax throttling for the frontbuffer). We also use it to
 * offer free GPU waitboosts for severely congested workloads.
 */
#define DRM_I915_THROTTLE_JIFFIES msecs_to_jiffies(20)

/*
 * Throttle our rendering by waiting until the ring has completed our requests
 * emitted over 20 msec ago.
 *
 * Note that if we were to use the current jiffies each time around the loop,
 * we wouldn't escape the function with any frames outstanding if the time to
 * render a frame was over 20ms.
 *
 * This should get us reasonable parallelism between CPU and GPU but also
 * relatively low latency when blocking on a particular request to finish.
 */
int
i915_gem_throttle_ioctl(struct drm_device *dev, void *data,
                        struct drm_file *file)
{
        const unsigned long recent_enough = jiffies - DRM_I915_THROTTLE_JIFFIES;
        struct drm_i915_file_private *file_priv = file->driver_priv;
        struct drm_i915_private *i915 = to_i915(dev);
        struct i915_gem_context *ctx;
        unsigned long idx;
        long ret;

        /* ABI: return -EIO if already wedged */
        ret = intel_gt_terminally_wedged(to_gt(i915));
        if (ret)
                return ret;

        rcu_read_lock();
        xa_for_each(&file_priv->context_xa, idx, ctx) {
                struct i915_gem_engines_iter it;
                struct intel_context *ce;

                if (!kref_get_unless_zero(&ctx->ref))
                        continue;
                rcu_read_unlock();

                for_each_gem_engine(ce,
                                    i915_gem_context_lock_engines(ctx),
                                    it) {
                        struct i915_request *rq, *target = NULL;

                        if (!ce->timeline)
                                continue;

                        mutex_lock(&ce->timeline->mutex);
                        list_for_each_entry_reverse(rq,
                                                    &ce->timeline->requests,
                                                    link) {
                                if (i915_request_completed(rq))
                                        break;

                                if (time_after(rq->emitted_jiffies,
                                               recent_enough))
                                        continue;

                                target = i915_request_get(rq);
                                break;
                        }
                        mutex_unlock(&ce->timeline->mutex);
                        if (!target)
                                continue;

                        ret = i915_request_wait(target,
                                                I915_WAIT_INTERRUPTIBLE,
                                                MAX_SCHEDULE_TIMEOUT);
                        i915_request_put(target);
                        if (ret < 0)
                                break;
                }
                i915_gem_context_unlock_engines(ctx);
                i915_gem_context_put(ctx);

                rcu_read_lock();
        }
        rcu_read_unlock();

        return ret < 0 ? ret : 0;
}