SUBTEST(igt_ppgtt_smoke_huge),
                SUBTEST(igt_ppgtt_sanity_check),
        };
-       struct drm_file *file;
        struct i915_gem_context *ctx;
        struct i915_address_space *vm;
+       struct file *file;
        int err;
 
        if (!HAS_PPGTT(i915)) {
        err = i915_subtests(tests, ctx);
 
 out_file:
-       mock_file_put(file);
+       fput(file);
        return err;
 }
 
        struct intel_engine_cs *engine;
        struct i915_gem_context **ctx;
        struct igt_live_test t;
-       struct drm_file *file;
+       struct file *file;
        unsigned long n;
        int err = -ENODEV;
 
        }
 
 out_file:
-       mock_file_put(file);
+       fput(file);
        return err;
 }
 
        int (* const *fn)(void *arg);
        struct i915_gem_context *ctx;
        struct intel_context *ce;
-       struct drm_file *file;
+       struct file *file;
        int n, m, count;
        int err = 0;
 
        }
        kfree(data);
 out_file:
-       mock_file_put(file);
+       fput(file);
        return err;
 }
 
        return err;
 }
 
-static int file_add_object(struct drm_file *file,
-                           struct drm_i915_gem_object *obj)
+static int file_add_object(struct file *file, struct drm_i915_gem_object *obj)
 {
        int err;
 
        GEM_BUG_ON(obj->base.handle_count);
 
        /* tie the object to the drm_file for easy reaping */
-       err = idr_alloc(&file->object_idr, &obj->base, 1, 0, GFP_KERNEL);
+       err = idr_alloc(&to_drm_file(file)->object_idr,
+                       &obj->base, 1, 0, GFP_KERNEL);
        if (err < 0)
-               return  err;
+               return err;
 
        i915_gem_object_get(obj);
        obj->base.handle_count++;
 
 static struct drm_i915_gem_object *
 create_test_object(struct i915_address_space *vm,
-                  struct drm_file *file,
+                  struct file *file,
                   struct list_head *objects)
 {
        struct drm_i915_gem_object *obj;
                unsigned long ncontexts, ndwords, dw;
                struct i915_request *tq[5] = {};
                struct igt_live_test t;
-               struct drm_file *file;
                IGT_TIMEOUT(end_time);
                LIST_HEAD(objects);
+               struct file *file;
 
                if (!intel_engine_can_store_dword(engine))
                        continue;
                if (igt_live_test_end(&t))
                        err = -EIO;
 
-               mock_file_put(file);
+               fput(file);
                if (err)
                        return err;
 
        struct i915_gem_context *parent;
        struct intel_engine_cs *engine;
        struct igt_live_test t;
-       struct drm_file *file;
+       struct file *file;
        int err = 0;
 
        /*
        if (igt_live_test_end(&t))
                err = -EIO;
 out_file:
-       mock_file_put(file);
+       fput(file);
        return err;
 }
 
        struct i915_gem_context *ctx;
        unsigned long idx, ndwords, dw;
        struct igt_live_test t;
-       struct drm_file *file;
        I915_RND_STATE(prng);
        IGT_TIMEOUT(end_time);
        LIST_HEAD(objects);
+       struct file *file;
        int err = -ENODEV;
 
        /*
        if (igt_live_test_end(&t))
                err = -EIO;
 
-       mock_file_put(file);
+       fput(file);
        return err;
 }
 
        struct i915_gem_context *ctx_a, *ctx_b;
        struct intel_engine_cs *engine;
        struct igt_live_test t;
-       struct drm_file *file;
        I915_RND_STATE(prng);
        unsigned long count;
+       struct file *file;
        u64 vm_total;
        int err;
 
 out_file:
        if (igt_live_test_end(&t))
                err = -EIO;
-       mock_file_put(file);
+       fput(file);
        return err;
 }
 
 
        struct drm_i915_gem_object *obj;
        struct i915_gem_context *ctx;
        struct intel_context *ce;
-       struct drm_file *file;
+       struct file *file;
        unsigned int prio;
        IGT_TIMEOUT(end);
        int err;
 
        intel_context_put(ce);
 out_file:
-       mock_file_put(file);
+       fput(file);
        return err;
 }
 
        struct drm_i915_gem_object *src, *dst;
        struct i915_gem_context *ctx;
        struct intel_context *ce;
-       struct drm_file *file;
+       struct file *file;
        unsigned int prio;
        IGT_TIMEOUT(end);
        int err;
 
        intel_context_put(ce);
 out_file:
-       mock_file_put(file);
+       fput(file);
        return err;
 }
 
 
  */
 
 #include "mock_context.h"
+#include "selftests/mock_drm.h"
 #include "selftests/mock_gtt.h"
 
 struct i915_gem_context *
 }
 
 struct i915_gem_context *
-live_context(struct drm_i915_private *i915, struct drm_file *file)
+live_context(struct drm_i915_private *i915, struct file *file)
 {
        struct i915_gem_context *ctx;
        int err;
        if (IS_ERR(ctx))
                return ctx;
 
-       err = gem_context_register(ctx, file->driver_priv);
+       err = gem_context_register(ctx, to_drm_file(file)->driver_priv);
        if (err < 0)
                goto err_ctx;
 
 
 void mock_context_close(struct i915_gem_context *ctx);
 
 struct i915_gem_context *
-live_context(struct drm_i915_private *i915, struct drm_file *file);
+live_context(struct drm_i915_private *i915, struct file *file);
 
 struct i915_gem_context *kernel_context(struct drm_i915_private *i915);
 void kernel_context_close(struct i915_gem_context *ctx);
 
        struct intel_engine_cs *engine;
        struct i915_gem_context *fixme;
        enum intel_engine_id id;
-       struct drm_file *file;
+       struct file *file;
        int err = 0;
 
        file = mock_file(gt->i915);
        }
 
 out_file:
-       mock_file_put(file);
+       fput(file);
        return err;
 }
 
        struct intel_engine_cs *engine;
        struct i915_gem_context *fixme;
        enum intel_engine_id id;
-       struct drm_file *file;
+       struct file *file;
        int err = 0;
 
        file = mock_file(gt->i915);
        }
 
 out_file:
-       mock_file_put(file);
+       fput(file);
        return err;
 }
 
 
        struct i915_gem_context *ctx;
        unsigned int reset_count, count;
        enum intel_engine_id id;
-       struct drm_file *file;
        IGT_TIMEOUT(end_time);
+       struct file *file;
        int err = 0;
 
        /* Check that we can reset during non-user portions of requests */
 
        err = igt_flush_test(gt->i915);
 out:
-       mock_file_put(file);
+       fput(file);
        if (intel_gt_is_wedged(gt))
                err = -EIO;
        return err;
        struct intel_engine_cs *engine;
        struct i915_gem_context *ctx;
        enum intel_engine_id id;
-       struct drm_file *file;
+       struct file *file;
        int err = 0;
 
        /* Check that we can engine-reset during non-user portions */
 
        err = igt_flush_test(gt->i915);
 out:
-       mock_file_put(file);
+       fput(file);
        if (intel_gt_is_wedged(gt))
                err = -EIO;
        return err;
        struct intel_engine_cs *engine = arg->engine;
        struct i915_request *rq[8] = {};
        struct i915_gem_context *ctx[ARRAY_SIZE(rq)];
-       struct drm_file *file;
        unsigned long count = 0;
+       struct file *file;
        int err = 0;
 
        file = mock_file(engine->i915);
        }
 
 err_file:
-       mock_file_put(file);
+       fput(file);
        return err;
 }
 
        struct intel_gt *gt = arg;
        struct i915_gem_context *ctx;
        struct i915_address_space *vm;
-       struct drm_file *file;
+       struct file *file;
        int err;
 
        file = mock_file(gt->i915);
        i915_vm_put(vm);
 
 out:
-       mock_file_put(file);
+       fput(file);
        return err;
 }
 
 
        struct intel_engine_cs *engine;
        struct i915_gem_context *ctx;
        enum intel_engine_id id;
-       struct drm_file *file;
+       struct file *file;
        int err = 0;
 
        /* Can the user write to the whitelisted registers? */
        }
 
 out_file:
-       mock_file_put(file);
+       fput(file);
        return err;
 }
 
 
        .minor = DRIVER_MINOR,
        .patchlevel = DRIVER_PATCHLEVEL,
 };
-
-#if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)
-#include "selftests/mock_drm.c"
-#endif
 
 {
        struct drm_i915_private *i915 = arg;
        struct i915_gem_context *ctx;
-       struct drm_file *file;
+       struct file *file;
        int err;
 
        file = mock_file(i915);
 
        err = switch_to_context(ctx);
 out:
-       mock_file_put(file);
+       fput(file);
        return err;
 }
 
 {
        struct drm_i915_private *i915 = arg;
        struct i915_gem_context *ctx;
-       struct drm_file *file;
+       struct file *file;
        int err;
 
        file = mock_file(i915);
 
        err = switch_to_context(ctx);
 out:
-       mock_file_put(file);
+       fput(file);
        return err;
 }
 
 
        /* Overfill the GGTT with context objects and so try to evict one. */
        for_each_engine(engine, gt, id) {
                struct i915_sw_fence fence;
-               struct drm_file *file;
+               struct file *file;
 
                file = mock_file(i915);
                if (IS_ERR(file)) {
                pr_info("Submitted %lu contexts/requests on %s\n",
                        count, engine->name);
 
-               mock_file_put(file);
+               fput(file);
                if (err)
                        break;
        }
 
                                      u64 hole_start, u64 hole_end,
                                      unsigned long end_time))
 {
-       struct drm_file *file;
        struct i915_ppgtt *ppgtt;
        IGT_TIMEOUT(end_time);
+       struct file *file;
        int err;
 
        if (!HAS_FULL_PPGTT(dev_priv))
        i915_vm_put(&ppgtt->vm);
 
 out_free:
-       mock_file_put(file);
+       fput(file);
        return err;
 }
 
        struct i915_address_space *vm;
        struct i915_gem_context *ctx;
        struct intel_context *ce;
-       struct drm_file *file;
        struct i915_vma *vma;
        I915_RND_STATE(prng);
+       struct file *file;
        unsigned int i;
        u32 *result;
        u32 *batch;
 out_vm:
        i915_vm_put(vm);
 out_unlock:
-       mock_file_put(file);
+       fput(file);
        return err;
 }
 
 
        struct task_struct **threads;
        struct igt_live_test live;
        intel_wakeref_t wakeref;
-       struct drm_file *file;
        struct smoketest *smoke;
        unsigned int n, idx;
+       struct file *file;
        int ret = 0;
 
        /*
 out_smoke:
        kfree(smoke);
 out_file:
-       mock_file_put(file);
+       fput(file);
 out_rpm:
        intel_runtime_pm_put(&i915->runtime_pm, wakeref);
 
 
        struct drm_i915_private *i915 = arg;
        struct drm_i915_gem_object *obj;
        struct i915_gem_context *ctx;
-       struct drm_file *file;
+       struct file *file;
        I915_RND_STATE(prng);
        u32 sz;
        int err;
 out_put:
        i915_gem_object_put(obj);
 out_file:
-       mock_file_put(file);
+       fput(file);
        return err;
 }
 
 
+++ /dev/null
-/*
- * Copyright © 2017 Intel Corporation
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- *
- */
-
-#include <drm/drm_file.h>
-
-#include "mock_drm.h"
-
-struct drm_file *mock_file(struct drm_i915_private *i915)
-{
-       struct file *file;
-
-       file = mock_drm_getfile(i915->drm.primary, O_RDWR);
-       if (IS_ERR(file))
-               return ERR_CAST(file);
-
-       return file->private_data;
-}
 
 #ifndef __MOCK_DRM_H
 #define __MOCK_DRM_H
 
-struct drm_file;
+#include <drm/drm_file.h>
+
 struct drm_i915_private;
+struct drm_file;
+struct file;
+
+static inline struct file *mock_file(struct drm_i915_private *i915)
+{
+       return mock_drm_getfile(i915->drm.primary, O_RDWR);
+}
 
-struct drm_file *mock_file(struct drm_i915_private *i915);
-static inline void mock_file_put(struct drm_file *file)
+static inline struct drm_file *to_drm_file(struct file *f)
 {
-       fput(file->filp);
+       return f->private_data;
 }
 
 #endif /* !__MOCK_DRM_H */