[Intel-gfx] [PATCH i-g-t 1/2] lib: Open debugfs files for the given DRM device
Robert Foss
robert.foss at collabora.com
Thu Mar 9 21:07:32 UTC 2017
I've only found a very minor nitpick in intel_watermark.c,
other than that this patch does not apply cleanly on upstream/master,
so I've run no compilation or runtime tests.
When it applies to trunk, feel free to add my r-b.
On 2017-03-08 08:29 AM, Tomeu Vizoso wrote:
> When opening a DRM debugfs file, locate the right path based on the
> given DRM device FD.
>
> This is needed so, in setups with more than one DRM device, any
> operations on debugfs files affect the expected DRM device.
>
> Signed-off-by: Tomeu Vizoso <tomeu.vizoso at collabora.com>
>
> ---
>
> Guess we could be more conservative and just rename the existing
> functions to have a _legacy postfix and have the new ones accept a FD
> param. Then existing i915-specific code could keep opening the first
> debugfs dir that contains i915-prefixed files and only the generic tests
> would need to be changed to pass the DRM fd.
>
> But the "right" thing to do is to not assume that there's only one DRM
> device on the system, so maybe we want to do the changes in this patch.
> ---
> benchmarks/gem_latency.c | 2 +-
> lib/drmtest.c | 2 +-
> lib/igt_debugfs.c | 181
+++++++++++++++++++++++---------------
> lib/igt_debugfs.h | 28 +++---
> lib/igt_gt.c | 12 +--
> lib/igt_gt.h | 4 +-
> lib/igt_kms.c | 10 +--
> lib/igt_kms.h | 4 +-
> lib/intel_io.h | 2 +-
> lib/intel_mmio.c | 4 +-
> tests/drv_hangman.c | 4 +-
> tests/drv_missed_irq.c | 37 ++++----
> tests/drv_suspend.c | 8 +-
> tests/gem_eio.c | 2 +-
> tests/gem_exec_latency.c | 2 +-
> tests/gem_exec_parse.c | 2 +-
> tests/gem_exec_whisper.c | 6 +-
> tests/gem_mocs_settings.c | 14 +--
> tests/gem_persistent_relocs.c | 2 +-
> tests/gem_ppgtt.c | 10 +--
> tests/gem_reloc_vs_gpu.c | 2 +-
> tests/gem_seqno_wrap.c | 24 ++---
> tests/gem_tiled_swapping.c | 6 +-
> tests/gem_workarounds.c | 4 +-
> tests/kms_atomic_transition.c | 2 +-
> tests/kms_ccs.c | 4 +-
> tests/kms_chv_cursor_fail.c | 4 +-
> tests/kms_crtc_background_color.c | 4 +-
> tests/kms_cursor_crc.c | 4 +-
> tests/kms_cursor_legacy.c | 4 +-
> tests/kms_draw_crc.c | 2 +-
> tests/kms_fbc_crc.c | 8 +-
> tests/kms_fbcon_fbt.c | 44 ++++-----
> tests/kms_flip_tiling.c | 8 +-
> tests/kms_frontbuffer_tracking.c | 26 +++---
> tests/kms_invalid_dotclock.c | 6 +-
> tests/kms_mmap_write_crc.c | 4 +-
> tests/kms_mmio_vs_cs_flip.c | 6 +-
> tests/kms_pipe_color.c | 5 +-
> tests/kms_pipe_crc_basic.c | 12 +--
> tests/kms_plane.c | 4 +-
> tests/kms_plane_lowres.c | 14 ++-
> tests/kms_plane_multiple.c | 4 +-
> tests/kms_plane_scaling.c | 4 +-
> tests/kms_psr_sink_crc.c | 6 +-
> tests/kms_pwrite_crc.c | 4 +-
> tests/kms_rotation_crc.c | 4 +-
> tests/kms_sink_crc_basic.c | 8 +-
> tests/kms_universal_plane.c | 12 +--
> tests/perf.c | 16 ++--
> tests/pm_lpsp.c | 2 +-
> tests/pm_rpm.c | 6 +-
> tests/pm_sseu.c | 28 +++---
> tests/prime_mmap_kms.c | 2 +-
> tools/intel_display_crc.c | 2 +-
> tools/intel_display_poller.c | 8 +-
> tools/intel_dp_compliance.c | 6 +-
> tools/intel_forcewaked.c | 10 ++-
> tools/intel_gpu_top.c | 8 +-
> tools/intel_guc_logger.c | 10 ++-
> tools/intel_infoframes.c | 7 +-
> tools/intel_l3_parity.c | 2 +-
> tools/intel_panel_fitter.c | 9 +-
> tools/intel_perf_counters.c | 2 +-
> tools/intel_reg.c | 12 ++-
> tools/intel_watermark.c | 23 +++--
> 66 files changed, 405 insertions(+), 323 deletions(-)
>
> diff --git a/benchmarks/gem_latency.c b/benchmarks/gem_latency.c
> index 7be78f20358f..fc875f1acb0a 100644
> --- a/benchmarks/gem_latency.c
> +++ b/benchmarks/gem_latency.c
> @@ -470,7 +470,7 @@ static int run(int seconds,
> if (gen < 6)
> return IGT_EXIT_SKIP; /* Needs BCS timestamp */
>
> - intel_register_access_init(intel_get_pci_device(), false);
> + intel_register_access_init(intel_get_pci_device(), false, fd);
>
> if (gen == 6)
> timestamp_reg = REG(RCS_TIMESTAMP);
> diff --git a/lib/drmtest.c b/lib/drmtest.c
> index 065ab1198e79..35f71c0d4f45 100644
> --- a/lib/drmtest.c
> +++ b/lib/drmtest.c
> @@ -183,7 +183,7 @@ void gem_quiescent_gpu(int fd)
> gem_sync(fd, obj.handle);
> gem_close(fd, obj.handle);
>
> - igt_drop_caches_set(DROP_RETIRE | DROP_FREED);
> + igt_drop_caches_set(fd, DROP_RETIRE | DROP_FREED);
> }
>
> /**
> diff --git a/lib/igt_debugfs.c b/lib/igt_debugfs.c
> index e64d001b71cf..80a48d2dec81 100644
> --- a/lib/igt_debugfs.c
> +++ b/lib/igt_debugfs.c
> @@ -131,39 +131,34 @@ const char *igt_debugfs_mount(void)
> return "/sys/kernel/debug";
> }
>
> -static bool __igt_debugfs_init(igt_debugfs_t *debugfs)
> +static char *
> +igt_get_debugfs_path(int fd)
> {
> struct stat st;
> - int n;
> -
> - strcpy(debugfs->root, igt_debugfs_mount());
> - for (n = 0; n < 16; n++) {
> - int len = sprintf(debugfs->dri_path, "%s/dri/%d", debugfs->root, n);
> - sprintf(debugfs->dri_path + len, "/i915_error_state");
> - if (stat(debugfs->dri_path, &st) == 0) {
> - debugfs->dri_path[len] = '\0';
> - return true;
> - }
> - }
> + const char *debugfs_root;
> + char *debugfs_dri_path;
> + int len;
>
> - debugfs->dri_path[0] = '\0';
> - return false;
> -}
> -
> -static igt_debugfs_t *__igt_debugfs_singleton(void)
> -{
> - static igt_debugfs_t singleton;
> - static bool init_done = false;
> -
> - if (init_done)
> - return &singleton;
> + if (fstat(fd, &st)) {
> + igt_debug("Couldn't stat FD for DRM device: %s\n", strerror(errno));
> + return NULL;
> + }
>
> - if (__igt_debugfs_init(&singleton)) {
> - init_done = true;
> - return &singleton;
> - } else {
> + if (!S_ISCHR(st.st_mode)) {
> + igt_debug("FD for DRM device not a char device!\n");
> return NULL;
> }
> +
> + debugfs_root = igt_debugfs_mount();
> + debugfs_dri_path = calloc(1, strlen(debugfs_root) + 100);
> + len = sprintf(debugfs_dri_path, "%s/dri/%d", debugfs_root,
major(st.st_rdev));
> + sprintf(debugfs_dri_path + len, "/name");
> + if (stat(debugfs_dri_path, &st) == 0) {
> + debugfs_dri_path[len] = '\0';
> + return debugfs_dri_path;
> + }
> +
> + return NULL;
> }
>
> /**
> @@ -177,15 +172,19 @@ static igt_debugfs_t *__igt_debugfs_singleton(void)
> * Returns:
> * The Unix file descriptor for the debugfs file or -1 if that
didn't work out.
> */
> -int igt_debugfs_open(const char *filename, int mode)
> +int igt_debugfs_open(int fd, const char *filename, int mode)
> {
> char buf[1024];
> - igt_debugfs_t *debugfs = __igt_debugfs_singleton();
> + char *debugfs_dri_path;
>
> - if (!debugfs)
> + debugfs_dri_path = igt_get_debugfs_path(fd);
> + if (!debugfs_dri_path)
> return -1;
>
> - sprintf(buf, "%s/%s", debugfs->dri_path, filename);
> + sprintf(buf, "%s/%s", debugfs_dri_path, filename);
> +
> + free(debugfs_dri_path);
> +
> return open(buf, mode);
> }
>
> @@ -200,17 +199,21 @@ int igt_debugfs_open(const char *filename, int
mode)
> * Returns:
> * The libc FILE pointer for the debugfs file or NULL if that didn't
work out.
> */
> -FILE *igt_debugfs_fopen(const char *filename,
> +FILE *igt_debugfs_fopen(int fd,
> + const char *filename,
> const char *mode)
> {
> char buf[1024];
> + char *debugfs_dri_path;
>
> - igt_debugfs_t *debugfs = __igt_debugfs_singleton();
> -
> - if (!debugfs)
> + debugfs_dri_path = igt_get_debugfs_path(fd);
> + if (!debugfs_dri_path)
> return NULL;
>
> - sprintf(buf, "%s/%s", debugfs->dri_path, filename);
> + sprintf(buf, "%s/%s", debugfs_dri_path, filename);
> +
> + free(debugfs_dri_path);
> +
> return fopen(buf, mode);
> }
>
> @@ -224,12 +227,12 @@ FILE *igt_debugfs_fopen(const char *filename,
> * provided buffer, then closes the file. Users should make sure
that the buffer
> * provided is big enough to fit the whole file, plus one byte.
> */
> -void __igt_debugfs_read(const char *filename, char *buf, int buf_size)
> +void __igt_debugfs_read(int fd, const char *filename, char *buf, int
buf_size)
> {
> FILE *file;
> size_t n_read;
>
> - file = igt_debugfs_fopen(filename, "r");
> + file = igt_debugfs_fopen(fd, filename, "r");
> igt_assert(file);
>
> n_read = fread(buf, 1, buf_size - 1, file);
> @@ -250,14 +253,14 @@ void __igt_debugfs_read(const char *filename,
char *buf, int buf_size)
> *
> * Returns: True if the @substring is found to occur in @filename
> */
> -bool igt_debugfs_search(const char *filename, const char *substring)
> +bool igt_debugfs_search(int fd, const char *filename, const char
*substring)
> {
> FILE *file;
> size_t n = 0;
> char *line = NULL;
> bool matched = false;
>
> - file = igt_debugfs_fopen(filename, "r");
> + file = igt_debugfs_fopen(fd, filename, "r");
> igt_assert(file);
>
> while (getline(&line, &n, file) >= 0) {
> @@ -322,6 +325,7 @@ char *igt_crc_to_string(igt_crc_t *crc)
> #define LEGACY_LINE_LEN (6 * 8 + 5 + 1)
>
> struct _igt_pipe_crc {
> + int fd;
> int ctl_fd;
> int crc_fd;
> int flags;
> @@ -370,7 +374,7 @@ static bool igt_pipe_crc_do_start(igt_pipe_crc_t
*pipe_crc)
> if (!pipe_crc->is_legacy) {
> sprintf(buf, "crtc-%d/crc/data", pipe_crc->pipe);
> errno = 0;
> - pipe_crc->crc_fd = igt_debugfs_open(buf, pipe_crc->flags);
> + pipe_crc->crc_fd = igt_debugfs_open(pipe_crc->fd, buf,
pipe_crc->flags);
> if (pipe_crc->crc_fd == -1 && errno == EINVAL)
> return false;
> igt_assert_eq(errno, 0);
> @@ -387,23 +391,27 @@ static void igt_pipe_crc_pipe_off(int fd, enum
pipe pipe)
> igt_assert_eq(write(fd, buf, strlen(buf)), strlen(buf));
> }
>
> -static void igt_pipe_crc_reset(void)
> +static void igt_pipe_crc_reset(int drm_fd)
> {
> - igt_debugfs_t *debugfs = __igt_debugfs_singleton();
> int fd;
> struct dirent *dirent;
> char buf[128];
> const char *cmd = "none";
> bool done = false;
> DIR *dir;
> + char *debugfs_dri_path;
> +
> + debugfs_dri_path = igt_get_debugfs_path(drm_fd);
> + if (!debugfs_dri_path)
> + return;
>
> - dir = opendir(debugfs->dri_path);
> + dir = opendir(debugfs_dri_path);
> if (dir) {
> while ((dirent = readdir(dir))) {
> if (strcmp(dirent->d_name, "crtc-") != 0)
> continue;
>
> - sprintf(buf, "%s/%s/crc/control", debugfs->dri_path,
> + sprintf(buf, "%s/%s/crc/control", debugfs_dri_path,
> dirent->d_name);
> fd = open(buf, O_WRONLY);
> if (fd == -1)
> @@ -416,11 +424,12 @@ static void igt_pipe_crc_reset(void)
> }
> closedir(dir);
> }
> + free(debugfs_dri_path);
>
> if (done)
> return;
>
> - fd = igt_debugfs_open("i915_display_crc_ctl", O_WRONLY);
> + fd = igt_debugfs_open(drm_fd, "i915_display_crc_ctl", O_WRONLY);
> if (fd != -1) {
> igt_pipe_crc_pipe_off(fd, PIPE_A);
> igt_pipe_crc_pipe_off(fd, PIPE_B);
> @@ -432,7 +441,32 @@ static void igt_pipe_crc_reset(void)
>
> static void pipe_crc_exit_handler(int sig)
> {
> - igt_pipe_crc_reset();
> + struct dirent *dirent;
> + char buf[128];
> + DIR *dir;
> + int fd;
> +
> + dir = opendir("/dev/dri");
> + if (!dir)
> + return;
> +
> + /*
> + * Try to reset CRC capture for all DRM devices, this is only needed
> + * for the legacy CRC ABI and can be completely removed once the
> + * legacy codepaths are removed.
> + */
> + while ((dirent = readdir(dir))) {
> + if (strncmp(dirent->d_name, "card", 4) != 0)
> + continue;
> +
> + sprintf(buf, "/dev/dri/%s", dirent->d_name);
> + fd = open(buf, O_WRONLY);
> +
> + igt_pipe_crc_reset(fd);
> +
> + close(fd);
> + }
> + closedir(dir);
> }
>
> /**
> @@ -442,16 +476,16 @@ static void pipe_crc_exit_handler(int sig)
> * kernel. Uses igt_skip to automatically skip the test/subtest if
this isn't
> * the case.
> */
> -void igt_require_pipe_crc(void)
> +void igt_require_pipe_crc(int fd)
> {
> const char *cmd = "pipe A none";
> FILE *ctl;
> size_t written;
> int ret;
>
> - ctl = igt_debugfs_fopen("crtc-0/crc/control", "r+");
> + ctl = igt_debugfs_fopen(fd, "crtc-0/crc/control", "r+");
> if (!ctl) {
> - ctl = igt_debugfs_fopen("i915_display_crc_ctl", "r+");
> + ctl = igt_debugfs_fopen(fd, "i915_display_crc_ctl", "r+");
> igt_require_f(ctl,
> "No display_crc_ctl found, kernel too old\n");
> written = fwrite(cmd, 1, strlen(cmd), ctl);
> @@ -477,9 +511,9 @@ void igt_require_pipe_crc(void)
> *
> * See: https://01.org/linuxgraphics/gfx-docs/drm/gpu/i915.html#hotplug
> */
> -void igt_hpd_storm_set_threshold(unsigned int threshold)
> +void igt_hpd_storm_set_threshold(int drm_fd, unsigned int threshold)
> {
> - int fd = igt_debugfs_open("i915_hpd_storm_ctl", O_WRONLY);
> + int fd = igt_debugfs_open(drm_fd, "i915_hpd_storm_ctl", O_WRONLY);
> char buf[16];
>
> if (fd < 0)
> @@ -506,9 +540,9 @@ void igt_hpd_storm_set_threshold(unsigned int
threshold)
> *
> * See: https://01.org/linuxgraphics/gfx-docs/drm/gpu/i915.html#hotplug
> */
> -void igt_hpd_storm_reset(void)
> +void igt_hpd_storm_reset(int drm_fd)
> {
> - int fd = igt_debugfs_open("i915_hpd_storm_ctl", O_WRONLY);
> + int fd = igt_debugfs_open(drm_fd, "i915_hpd_storm_ctl", O_WRONLY);
> const char *buf = "reset";
>
> if (fd < 0)
> @@ -533,9 +567,9 @@ void igt_hpd_storm_reset(void)
> *
> * Returns: Whether or not an HPD storm has been detected.
> */
> -bool igt_hpd_storm_detected(void)
> +bool igt_hpd_storm_detected(int drm_fd)
> {
> - int fd = igt_debugfs_open("i915_hpd_storm_ctl", O_RDONLY);
> + int fd = igt_debugfs_open(drm_fd, "i915_hpd_storm_ctl", O_RDONLY);
> char *start_loc;
> char buf[32] = {0}, detected_str[4];
> bool ret;
> @@ -566,16 +600,16 @@ bool igt_hpd_storm_detected(void)
> *
> * See: https://01.org/linuxgraphics/gfx-docs/drm/gpu/i915.html#hotplug
> */
> -void igt_require_hpd_storm_ctl(void)
> +void igt_require_hpd_storm_ctl(int drm_fd)
> {
> - int fd = igt_debugfs_open("i915_hpd_storm_ctl", O_RDONLY);
> + int fd = igt_debugfs_open(drm_fd, "i915_hpd_storm_ctl", O_RDONLY);
>
> igt_require_f(fd > 0, "No i915_hpd_storm_ctl found in debugfs\n");
> close(fd);
> }
>
> static igt_pipe_crc_t *
> -pipe_crc_new(enum pipe pipe, enum intel_pipe_crc_source source, int
flags)
> +pipe_crc_new(int fd, enum pipe pipe, enum intel_pipe_crc_source
source, int flags)
> {
> igt_pipe_crc_t *pipe_crc;
> char buf[128];
> @@ -585,9 +619,9 @@ pipe_crc_new(enum pipe pipe, enum
intel_pipe_crc_source source, int flags)
> pipe_crc = calloc(1, sizeof(struct _igt_pipe_crc));
>
> sprintf(buf, "crtc-%d/crc/control", pipe);
> - pipe_crc->ctl_fd = igt_debugfs_open(buf, O_WRONLY);
> + pipe_crc->ctl_fd = igt_debugfs_open(fd, buf, O_WRONLY);
> if (pipe_crc->ctl_fd == -1) {
> - pipe_crc->ctl_fd = igt_debugfs_open("i915_display_crc_ctl",
> + pipe_crc->ctl_fd = igt_debugfs_open(fd, "i915_display_crc_ctl",
> O_WRONLY);
> igt_assert(pipe_crc->ctl_fd != -1);
> pipe_crc->is_legacy = true;
> @@ -595,7 +629,7 @@ pipe_crc_new(enum pipe pipe, enum
intel_pipe_crc_source source, int flags)
>
> if (pipe_crc->is_legacy) {
> sprintf(buf, "i915_pipe_%s_crc", kmstest_pipe_name(pipe));
> - pipe_crc->crc_fd = igt_debugfs_open(buf, flags);
> + pipe_crc->crc_fd = igt_debugfs_open(fd, buf, flags);
> igt_assert(pipe_crc->crc_fd != -1);
> igt_debug("Using legacy frame CRC ABI\n");
> } else {
> @@ -603,6 +637,7 @@ pipe_crc_new(enum pipe pipe, enum
intel_pipe_crc_source source, int flags)
> igt_debug("Using generic frame CRC ABI\n");
> }
>
> + pipe_crc->fd = fd;
> pipe_crc->pipe = pipe;
> pipe_crc->source = source;
> pipe_crc->flags = flags;
> @@ -623,9 +658,9 @@ pipe_crc_new(enum pipe pipe, enum
intel_pipe_crc_source source, int flags)
> * least INTEL_PIPE_CRC_SOURCE_AUTO everywhere.
> */
> igt_pipe_crc_t *
> -igt_pipe_crc_new(enum pipe pipe, enum intel_pipe_crc_source source)
> +igt_pipe_crc_new(int fd, enum pipe pipe, enum intel_pipe_crc_source
source)
> {
> - return pipe_crc_new(pipe, source, O_RDONLY);
> + return pipe_crc_new(fd, pipe, source, O_RDONLY);
> }
>
> /**
> @@ -641,9 +676,9 @@ igt_pipe_crc_new(enum pipe pipe, enum
intel_pipe_crc_source source)
> * least INTEL_PIPE_CRC_SOURCE_AUTO everywhere.
> */
> igt_pipe_crc_t *
> -igt_pipe_crc_new_nonblock(enum pipe pipe, enum intel_pipe_crc_source
source)
> +igt_pipe_crc_new_nonblock(int fd, enum pipe pipe, enum
intel_pipe_crc_source source)
> {
> - return pipe_crc_new(pipe, source, O_RDONLY | O_NONBLOCK);
> + return pipe_crc_new(fd, pipe, source, O_RDONLY | O_NONBLOCK);
> }
>
> /**
> @@ -879,7 +914,7 @@ void igt_pipe_crc_collect_crc(igt_pipe_crc_t
*pipe_crc, igt_crc_t *out_crc)
> * This calls the debugfs interface the drm/i915 GEM driver exposes
to drop or
> * evict certain classes of gem buffer objects.
> */
> -void igt_drop_caches_set(uint64_t val)
> +void igt_drop_caches_set(int drm_fd, uint64_t val)
> {
> int fd;
> char data[19];
> @@ -887,7 +922,7 @@ void igt_drop_caches_set(uint64_t val)
>
> sprintf(data, "0x%" PRIx64, val);
>
> - fd = igt_debugfs_open("i915_gem_drop_caches", O_WRONLY);
> + fd = igt_debugfs_open(drm_fd, "i915_gem_drop_caches", O_WRONLY);
>
> igt_assert(fd >= 0);
> do {
> @@ -953,14 +988,14 @@ void igt_enable_prefault(void)
> igt_prefault_control(true);
> }
>
> -static int get_object_count(void)
> +static int get_object_count(int fd)
> {
> FILE *file;
> int ret, scanned;
>
> - igt_drop_caches_set(DROP_RETIRE | DROP_ACTIVE | DROP_FREED);
> + igt_drop_caches_set(fd, DROP_RETIRE | DROP_ACTIVE | DROP_FREED);
>
> - file = igt_debugfs_fopen("i915_gem_objects", "r");
> + file = igt_debugfs_fopen(fd, "i915_gem_objects", "r");
>
> scanned = fscanf(file, "%i objects", &ret);
> igt_assert_eq(scanned, 1);
> @@ -980,7 +1015,7 @@ int igt_get_stable_obj_count(int driver)
> {
> int obj_count;
> gem_quiescent_gpu(driver);
> - obj_count = get_object_count();
> + obj_count = get_object_count(driver);
> /* The test relies on the system being in the same state before and
> * after the test so any difference in the object count is a result of
> * leaks during the test. gem_quiescent_gpu() mostly achieves this but
> @@ -994,7 +1029,7 @@ int igt_get_stable_obj_count(int driver)
> while (loop_count < 4) {
> usleep(200000);
> gem_quiescent_gpu(driver);
> - obj_count = get_object_count();
> + obj_count = get_object_count(driver);
> if (obj_count == prev_obj_count) {
> loop_count++;
> } else {
> diff --git a/lib/igt_debugfs.h b/lib/igt_debugfs.h
> index 5587ad40b3b8..9bede52f517b 100644
> --- a/lib/igt_debugfs.h
> +++ b/lib/igt_debugfs.h
> @@ -33,11 +33,11 @@ enum pipe;
>
> const char *igt_debugfs_mount(void);
>
> -int igt_debugfs_open(const char *filename, int mode);
> -FILE *igt_debugfs_fopen(const char *filename,
> +int igt_debugfs_open(int fd, const char *filename, int mode);
> +FILE *igt_debugfs_fopen(int fd, const char *filename,
> const char *mode);
> -void __igt_debugfs_read(const char *filename, char *buf, int buf_size);
> -bool igt_debugfs_search(const char *filename, const char *substring);
> +void __igt_debugfs_read(int fd, const char *filename, char *buf, int
buf_size);
> +bool igt_debugfs_search(int fd, const char *filename, const char
*substring);
>
> /**
> * igt_debugfs_read:
> @@ -47,8 +47,8 @@ bool igt_debugfs_search(const char *filename, const
char *substring);
> * This is just a convenience wrapper for __igt_debugfs_read. See its
> * documentation.
> */
> -#define igt_debugfs_read(filename, buf) \
> - __igt_debugfs_read((filename), (buf), sizeof(buf))
> +#define igt_debugfs_read(fd, filename, buf) \
> + __igt_debugfs_read(fd, (filename), (buf), sizeof(buf))
>
> /*
> * Pipe CRC
> @@ -116,11 +116,11 @@ enum intel_pipe_crc_source {
> void igt_assert_crc_equal(const igt_crc_t *a, const igt_crc_t *b);
> char *igt_crc_to_string(igt_crc_t *crc);
>
> -void igt_require_pipe_crc(void);
> +void igt_require_pipe_crc(int fd);
> igt_pipe_crc_t *
> -igt_pipe_crc_new(enum pipe pipe, enum intel_pipe_crc_source source);
> +igt_pipe_crc_new(int fd, enum pipe pipe, enum intel_pipe_crc_source
source);
> igt_pipe_crc_t *
> -igt_pipe_crc_new_nonblock(enum pipe pipe, enum intel_pipe_crc_source
source);
> +igt_pipe_crc_new_nonblock(int fd, enum pipe pipe, enum
intel_pipe_crc_source source);
> void igt_pipe_crc_free(igt_pipe_crc_t *pipe_crc);
> void igt_pipe_crc_start(igt_pipe_crc_t *pipe_crc);
> void igt_pipe_crc_stop(igt_pipe_crc_t *pipe_crc);
> @@ -129,10 +129,10 @@ int igt_pipe_crc_get_crcs(igt_pipe_crc_t
*pipe_crc, int n_crcs,
> igt_crc_t **out_crcs);
> void igt_pipe_crc_collect_crc(igt_pipe_crc_t *pipe_crc, igt_crc_t
*out_crc);
>
> -void igt_hpd_storm_set_threshold(unsigned int threshold);
> -void igt_hpd_storm_reset(void);
> -bool igt_hpd_storm_detected(void);
> -void igt_require_hpd_storm_ctl(void);
> +void igt_hpd_storm_set_threshold(int fd, unsigned int threshold);
> +void igt_hpd_storm_reset(int fd);
> +bool igt_hpd_storm_detected(int fd);
> +void igt_require_hpd_storm_ctl(int fd);
>
> /*
> * Drop caches
> @@ -180,7 +180,7 @@ void igt_require_hpd_storm_ctl(void);
> DROP_ACTIVE | \
> DROP_FREED)
>
> -void igt_drop_caches_set(uint64_t val);
> +void igt_drop_caches_set(int fd, uint64_t val);
>
> /*
> * Prefault control
> diff --git a/lib/igt_gt.c b/lib/igt_gt.c
> index 3bfaf2e4d849..e47d9a4cd5f7 100644
> --- a/lib/igt_gt.c
> +++ b/lib/igt_gt.c
> @@ -362,13 +362,13 @@ void igt_post_hang_ring(int fd, igt_hang_t arg)
> * stuck, either because the test manually disabled gpu resets or
because the
> * test hit an hangcheck bug
> */
> -void igt_force_gpu_reset(void)
> +void igt_force_gpu_reset(int drm_fd)
> {
> int fd, ret;
>
> igt_debug("Triggering GPU reset\n");
>
> - fd = igt_debugfs_open("i915_wedged", O_RDWR);
> + fd = igt_debugfs_open(drm_fd, "i915_wedged", O_RDWR);
> igt_require(fd >= 0);
>
> ret = write(fd, "-1\n", 3);
> @@ -443,11 +443,11 @@ void igt_stop_hang_helper(void)
> * Returns:
> * The file descriptor of the forcewake handle or -1 if that didn't
work out.
> */
> -int igt_open_forcewake_handle(void)
> +int igt_open_forcewake_handle(int fd)
> {
> if (getenv("IGT_NO_FORCEWAKE"))
> return -1;
> - return igt_debugfs_open("i915_forcewake_user", O_WRONLY);
> + return igt_debugfs_open(fd, "i915_forcewake_user", O_WRONLY);
> }
>
> #if defined(__x86_64__) || defined(__i386__)
> @@ -535,13 +535,13 @@ unsigned
intel_detect_and_clear_missed_interrupts(int fd)
>
> gem_quiescent_gpu(fd);
>
> - file = igt_debugfs_fopen("i915_ring_missed_irq", "r");
> + file = igt_debugfs_fopen(fd, "i915_ring_missed_irq", "r");
> if (file) {
> igt_assert(fscanf(file, "%x", &missed) == 1);
> fclose(file);
> }
> if (missed) {
> - file = igt_debugfs_fopen("i915_ring_missed_irq", "w");
> + file = igt_debugfs_fopen(fd, "i915_ring_missed_irq", "w");
> if (file) {
> fwrite("0\n", 1, 2, file);
> fclose(file);
> diff --git a/lib/igt_gt.h b/lib/igt_gt.h
> index e44b6db1b961..1ed833d2fbcc 100644
> --- a/lib/igt_gt.h
> +++ b/lib/igt_gt.h
> @@ -51,12 +51,12 @@ igt_hang_t igt_hang_ctx(int fd,
> igt_hang_t igt_hang_ring(int fd, int ring);
> void igt_post_hang_ring(int fd, igt_hang_t arg);
>
> -void igt_force_gpu_reset(void);
> +void igt_force_gpu_reset(int fd);
>
> void igt_fork_hang_helper(void);
> void igt_stop_hang_helper(void);
>
> -int igt_open_forcewake_handle(void);
> +int igt_open_forcewake_handle(int fd);
>
> int igt_setup_clflush(void);
> void igt_clflush_range(void *addr, int size);
> diff --git a/lib/igt_kms.c b/lib/igt_kms.c
> index 8751c97f7a06..6b7f4fb9711e 100644
> --- a/lib/igt_kms.c
> +++ b/lib/igt_kms.c
> @@ -747,7 +747,7 @@ void kmstest_force_edid(int drm_fd,
drmModeConnector *connector,
>
> igt_assert_neq(asprintf(&path, "%s-%d/edid_override",
kmstest_connector_type_str(connector->connector_type),
connector->connector_type_id),
> -1);
> - debugfs_fd = igt_debugfs_open(path, O_WRONLY | O_TRUNC);
> + debugfs_fd = igt_debugfs_open(drm_fd, path, O_WRONLY | O_TRUNC);
> free(path);
>
> igt_assert(debugfs_fd != -1);
> @@ -1324,7 +1324,7 @@ static void parse_crtc(char *info, struct
kmstest_crtc *crtc)
> igt_assert_eq(ret, 2);
> }
>
> -void kmstest_get_crtc(enum pipe pipe, struct kmstest_crtc *crtc)
> +void kmstest_get_crtc(int fd, enum pipe pipe, struct kmstest_crtc *crtc)
> {
> char tmp[256];
> FILE *fid;
> @@ -1333,7 +1333,7 @@ void kmstest_get_crtc(enum pipe pipe, struct
kmstest_crtc *crtc)
> int line;
> long int n;
>
> - fid = igt_debugfs_fopen("i915_display_info", mode);
> + fid = igt_debugfs_fopen(fd, "i915_display_info", mode);
>
> igt_skip_on(fid == NULL);
>
> @@ -1370,13 +1370,13 @@ void kmstest_get_crtc(enum pipe pipe, struct
kmstest_crtc *crtc)
> igt_skip_on(ncrtc == 0);
> }
>
> -void igt_assert_plane_visible(enum pipe pipe, bool visibility)
> +void igt_assert_plane_visible(int fd, enum pipe pipe, bool visibility)
> {
> struct kmstest_crtc crtc;
> int i;
> bool visible;
>
> - kmstest_get_crtc(pipe, &crtc);
> + kmstest_get_crtc(fd, pipe, &crtc);
>
> visible = true;
> for (i = 0; i < crtc.n_planes; i++) {
> diff --git a/lib/igt_kms.h b/lib/igt_kms.h
> index 6754d00e0a3a..5efce0049b08 100644
> --- a/lib/igt_kms.h
> +++ b/lib/igt_kms.h
> @@ -215,8 +215,8 @@ uint32_t kmstest_dumb_create(int fd, int width,
int height, int bpp,
> void *kmstest_dumb_map_buffer(int fd, uint32_t handle, uint64_t size,
> unsigned prot);
> unsigned int kmstest_get_vblank(int fd, int pipe, unsigned int flags);
> -void kmstest_get_crtc(enum pipe pipe, struct kmstest_crtc *crtc);
> -void igt_assert_plane_visible(enum pipe pipe, bool visibility);
> +void kmstest_get_crtc(int fd, enum pipe pipe, struct kmstest_crtc
*crtc);
> +void igt_assert_plane_visible(int fd, enum pipe pipe, bool visibility);
>
> /*
> * A small modeset API
> diff --git a/lib/intel_io.h b/lib/intel_io.h
> index e2d6b4705be3..6014c4855cab 100644
> --- a/lib/intel_io.h
> +++ b/lib/intel_io.h
> @@ -36,7 +36,7 @@ extern void *igt_global_mmio;
> void intel_mmio_use_pci_bar(struct pci_device *pci_dev);
> void intel_mmio_use_dump_file(char *file);
>
> -int intel_register_access_init(struct pci_device *pci_dev, int safe);
> +int intel_register_access_init(struct pci_device *pci_dev, int safe,
int fd);
> void intel_register_access_fini(void);
> uint32_t intel_register_read(uint32_t reg);
> void intel_register_write(uint32_t reg, uint32_t val);
> diff --git a/lib/intel_mmio.c b/lib/intel_mmio.c
> index 4981daf911c9..07b9ed1471b7 100644
> --- a/lib/intel_mmio.c
> +++ b/lib/intel_mmio.c
> @@ -165,7 +165,7 @@ release_forcewake_lock(int fd)
> * @pci_dev can be obtained from intel_get_pci_device().
> */
> int
> -intel_register_access_init(struct pci_device *pci_dev, int safe)
> +intel_register_access_init(struct pci_device *pci_dev, int safe, int fd)
> {
> int ret;
>
> @@ -187,7 +187,7 @@ intel_register_access_init(struct pci_device
*pci_dev, int safe)
> /* Find where the forcewake lock is. Forcewake doesn't exist
> * gen < 6, but the debugfs should do the right things for us.
> */
> - ret = igt_open_forcewake_handle();
> + ret = igt_open_forcewake_handle(fd);
> if (ret == -1)
> mmio_data.key = FAKEKEY;
> else
> diff --git a/tests/drv_hangman.c b/tests/drv_hangman.c
> index 51bdbdaaa98a..ee03c0a1abec 100644
> --- a/tests/drv_hangman.c
> +++ b/tests/drv_hangman.c
> @@ -88,7 +88,7 @@ static void test_error_state_basic(void)
> assert_error_state_clear();
>
> /* Manually trigger a hang by request a reset */
> - fd = igt_debugfs_open("i915_wedged", O_WRONLY);
> + fd = igt_debugfs_open(device, "i915_wedged", O_WRONLY);
> igt_ignore_warn(write(fd, "1\n", 2));
> close(fd);
>
> @@ -227,7 +227,7 @@ static void hangcheck_unterminated(void)
> gem_execbuf(device, &execbuf);
> if (gem_wait(device, handle, &timeout_ns) != 0) {
> /* need to manually trigger an hang to clean before failing */
> - igt_force_gpu_reset();
> + igt_force_gpu_reset(device);
> igt_assert_f(0, "unterminated batch did not trigger an hang!");
> }
> }
> diff --git a/tests/drv_missed_irq.c b/tests/drv_missed_irq.c
> index 3b789a6c7ecf..eaf565ea545f 100644
> --- a/tests/drv_missed_irq.c
> +++ b/tests/drv_missed_irq.c
> @@ -29,6 +29,8 @@
>
> IGT_TEST_DESCRIPTION("Inject missed interrupts and make sure they
are caught");
>
> +static int drm_fd;
> +
> static void trigger_missed_interrupt(int fd, unsigned ring)
> {
> const int gen = intel_gen(intel_get_drm_devid(fd));
> @@ -116,16 +118,16 @@ static uint32_t engine_mask(void)
> uint32_t mask;
> FILE *file;
>
> - file = igt_debugfs_fopen("i915_ring_test_irq", "w");
> + file = igt_debugfs_fopen(drm_fd, "i915_ring_test_irq", "w");
> fprintf(file, "0x%x", -1);
> fclose(file);
>
> mask = -1;
> - file = igt_debugfs_fopen("i915_ring_test_irq", "r");
> + file = igt_debugfs_fopen(drm_fd, "i915_ring_test_irq", "r");
> igt_ignore_warn(fscanf(file, "%x", &mask));
> fclose(file);
>
> - file = igt_debugfs_fopen("i915_ring_test_irq", "w");
> + file = igt_debugfs_fopen(drm_fd, "i915_ring_test_irq", "w");
> fprintf(file, "0");
> fclose(file);
>
> @@ -136,7 +138,7 @@ static void enable_missed_irq(void)
> {
> FILE *file;
>
> - file = igt_debugfs_fopen("i915_ring_test_irq", "w");
> + file = igt_debugfs_fopen(drm_fd, "i915_ring_test_irq", "w");
> fprintf(file, "0x%x", -1);
> fclose(file);
> }
> @@ -146,11 +148,11 @@ static uint32_t disable_missed_irq(void)
> FILE *file;
> uint32_t mask = 0;
>
> - file = igt_debugfs_fopen("i915_ring_test_irq", "r");
> + file = igt_debugfs_fopen(drm_fd, "i915_ring_test_irq", "r");
> igt_ignore_warn(fscanf(file, "%x", &mask));
> fclose(file);
>
> - file = igt_debugfs_fopen("i915_ring_test_irq", "w");
> + file = igt_debugfs_fopen(drm_fd, "i915_ring_test_irq", "w");
> fprintf(file, "0");
> fclose(file);
>
> @@ -163,20 +165,19 @@ igt_simple_main
> unsigned expect_rings;
> unsigned missed_rings;
> unsigned check_rings;
> - int fd;
>
> igt_skip_on_simulation();
> bind_to_cpu(0);
>
> - fd = drm_open_driver(DRIVER_INTEL);
> - igt_require_gem(fd);
> - gem_require_mmap_wc(fd);
> - igt_fork_hang_detector(fd);
> + drm_fd = drm_open_driver(DRIVER_INTEL);
> + igt_require_gem(drm_fd);
> + gem_require_mmap_wc(drm_fd);
> + igt_fork_hang_detector(drm_fd);
>
> expect_rings = engine_mask();
>
> igt_debug("Clearing rings %x\n", expect_rings);
> - intel_detect_and_clear_missed_interrupts(fd);
> + intel_detect_and_clear_missed_interrupts(drm_fd);
> for (e = intel_execution_engines; e->name; e++) {
> if (expect_rings == -1 && e->exec_id)
> continue;
> @@ -186,14 +187,14 @@ igt_simple_main
>
> igt_debug("Clearing ring %s [%x]\n",
> e->name, e->exec_id | e->flags);
> - trigger_missed_interrupt(fd, e->exec_id | e->flags);
> + trigger_missed_interrupt(drm_fd, e->exec_id | e->flags);
> }
> - igt_assert_eq(intel_detect_and_clear_missed_interrupts(fd), 0);
> + igt_assert_eq(intel_detect_and_clear_missed_interrupts(drm_fd), 0);
>
> igt_debug("Testing rings %x\n", expect_rings);
> enable_missed_irq();
>
> - intel_detect_and_clear_missed_interrupts(fd);
> + intel_detect_and_clear_missed_interrupts(drm_fd);
> for (e = intel_execution_engines; e->name; e++) {
> if (expect_rings == -1 && e->exec_id)
> continue;
> @@ -203,9 +204,9 @@ igt_simple_main
>
> igt_debug("Executing on ring %s [%x]\n",
> e->name, e->exec_id | e->flags);
> - trigger_missed_interrupt(fd, e->exec_id | e->flags);
> + trigger_missed_interrupt(drm_fd, e->exec_id | e->flags);
> }
> - missed_rings = intel_detect_and_clear_missed_interrupts(fd);
> + missed_rings = intel_detect_and_clear_missed_interrupts(drm_fd);
>
> check_rings = disable_missed_irq();
> igt_assert_eq_u32(check_rings, expect_rings);
> @@ -216,5 +217,5 @@ igt_simple_main
> igt_assert_eq_u32(missed_rings, expect_rings);
>
> igt_stop_hang_detector();
> - close(fd);
> + close(drm_fd);
> }
> diff --git a/tests/drv_suspend.c b/tests/drv_suspend.c
> index 1d7cc1f8200b..2e39f20ae26c 100644
> --- a/tests/drv_suspend.c
> +++ b/tests/drv_suspend.c
> @@ -161,11 +161,11 @@ test_sysfs_reader(bool hibernate)
> }
>
> static void
> -test_forcewake(bool hibernate)
> +test_forcewake(int fd, bool hibernate)
> {
> int fw_fd;
>
> - fw_fd = igt_open_forcewake_handle();
> + fw_fd = igt_open_forcewake_handle(fd);
> igt_assert_lte(0, fw_fd);
>
> if (hibernate)
> @@ -200,7 +200,7 @@ igt_main
> test_sysfs_reader(false);
>
> igt_subtest("forcewake")
> - test_forcewake(false);
> + test_forcewake(fd, false);
>
> igt_subtest("fence-restore-tiled2untiled-hibernate")
> test_fence_restore(fd, true, true);
> @@ -215,7 +215,7 @@ igt_main
> test_sysfs_reader(true);
>
> igt_subtest("forcewake-hibernate")
> - test_forcewake(true);
> + test_forcewake(fd, true);
>
> igt_fixture
> close(fd);
> diff --git a/tests/gem_eio.c b/tests/gem_eio.c
> index 22fcf439f09f..fc94ffef924d 100644
> --- a/tests/gem_eio.c
> +++ b/tests/gem_eio.c
> @@ -61,7 +61,7 @@ static bool i915_reset_control(bool enable)
>
> static void trigger_reset(int fd)
> {
> - igt_force_gpu_reset();
> + igt_force_gpu_reset(fd);
>
> /* And just check the gpu is indeed running again */
> igt_debug("Checking that the GPU recovered\n");
> diff --git a/tests/gem_exec_latency.c b/tests/gem_exec_latency.c
> index c3ebc20ab3c0..dd6703f43a38 100644
> --- a/tests/gem_exec_latency.c
> +++ b/tests/gem_exec_latency.c
> @@ -442,9 +442,9 @@ igt_main
> int device = -1;
>
> igt_fixture {
> - intel_register_access_init(intel_get_pci_device(), false);
> device = drm_open_driver(DRIVER_INTEL);
> igt_require_gem(device);
> + intel_register_access_init(intel_get_pci_device(), false, device);
> print_welcome(device);
>
> ring_size = measure_ring_size(device);
> diff --git a/tests/gem_exec_parse.c b/tests/gem_exec_parse.c
> index ff438b2519b9..4e6d85e58113 100644
> --- a/tests/gem_exec_parse.c
> +++ b/tests/gem_exec_parse.c
> @@ -521,7 +521,7 @@ igt_main
> #undef REG
>
> igt_fixture {
> - intel_register_access_init(intel_get_pci_device(), 0);
> + intel_register_access_init(intel_get_pci_device(), 0, fd);
> }
>
> for (int i = 0; i < ARRAY_SIZE(lris); i++) {
> diff --git a/tests/gem_exec_whisper.c b/tests/gem_exec_whisper.c
> index cac3fedd21db..04ccc7f0e4d0 100644
> --- a/tests/gem_exec_whisper.c
> +++ b/tests/gem_exec_whisper.c
> @@ -41,12 +41,12 @@
>
> #define VERIFY 0
>
> -static void write_seqno(unsigned offset)
> +static void write_seqno(int fd, unsigned offset)
> {
> uint32_t seqno = UINT32_MAX - offset;
> FILE *file;
>
> - file = igt_debugfs_fopen("i915_next_seqno", "w");
> + file = igt_debugfs_fopen(fd, "i915_next_seqno", "w");
> igt_assert(file);
>
> igt_assert(fprintf(file, "0x%x", seqno) > 0);
> @@ -337,7 +337,7 @@ static void whisper(int fd, unsigned engine,
unsigned flags)
> uint64_t offset;
>
> if (!(flags & FORKED))
> - write_seqno(pass);
> + write_seqno(fd, pass);
>
> if (flags & HANG)
> submit_hang(&hang, engines, nengine);
> diff --git a/tests/gem_mocs_settings.c b/tests/gem_mocs_settings.c
> index 9faf6c5492af..a96aa66d26a0 100644
> --- a/tests/gem_mocs_settings.c
> +++ b/tests/gem_mocs_settings.c
> @@ -383,7 +383,7 @@ static void default_context_tests(unsigned mode)
>
> switch (mode) {
> case NONE: break;
> - case RESET: igt_force_gpu_reset(); break;
> + case RESET: igt_force_gpu_reset(fd); break;
> case SUSPEND: igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
> SUSPEND_TEST_NONE); break;
> case HIBERNATE: igt_system_suspend_autoresume(SUSPEND_STATE_DISK,
> @@ -424,7 +424,7 @@ static void default_dirty_tests(unsigned mode)
>
> switch (mode) {
> case NONE: break;
> - case RESET: igt_force_gpu_reset(); break;
> + case RESET: igt_force_gpu_reset(fd); break;
> case SUSPEND: igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
> SUSPEND_TEST_NONE); break;
> case HIBERNATE: igt_system_suspend_autoresume(SUSPEND_STATE_DISK,
> @@ -449,7 +449,7 @@ static void context_save_restore_test(unsigned mode)
>
> switch (mode) {
> case NONE: break;
> - case RESET: igt_force_gpu_reset(); break;
> + case RESET: igt_force_gpu_reset(fd); break;
> case SUSPEND: igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
> SUSPEND_TEST_NONE); break;
> case HIBERNATE: igt_system_suspend_autoresume(SUSPEND_STATE_DISK,
> @@ -494,7 +494,7 @@ static void context_dirty_test(unsigned mode)
>
> switch (mode) {
> case NONE: break;
> - case RESET: igt_force_gpu_reset(); break;
> + case RESET: igt_force_gpu_reset(fd); break;
> case SUSPEND: igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
> SUSPEND_TEST_NONE); break;
> case HIBERNATE: igt_system_suspend_autoresume(SUSPEND_STATE_DISK,
> @@ -514,10 +514,14 @@ static void context_dirty_test(unsigned mode)
> static void run_tests(unsigned mode)
> {
> struct pci_device *pci_dev;
> + int fd;
>
> pci_dev = intel_get_pci_device();
> igt_require(pci_dev);
> - intel_register_access_init(pci_dev, 0);
> +
> + fd = drm_open_driver_master(DRIVER_INTEL);
> + intel_register_access_init(pci_dev, 0, fd);
> + close(fd);
>
> default_context_tests(mode);
> default_dirty_tests(mode);
> diff --git a/tests/gem_persistent_relocs.c
b/tests/gem_persistent_relocs.c
> index 9c885307df63..e51420e1672a 100644
> --- a/tests/gem_persistent_relocs.c
> +++ b/tests/gem_persistent_relocs.c
> @@ -288,7 +288,7 @@ static void do_forked_test(int fd, unsigned flags)
> igt_fork_helper(&thrasher) {
> while (1) {
> usleep(1000);
> - igt_drop_caches_set(val);
> + igt_drop_caches_set(fd, val);
> }
> }
> }
> diff --git a/tests/gem_ppgtt.c b/tests/gem_ppgtt.c
> index a64d6d4f056d..37d601ced843 100644
> --- a/tests/gem_ppgtt.c
> +++ b/tests/gem_ppgtt.c
> @@ -236,7 +236,7 @@ static void flink_and_close(void)
> gem_sync(fd2, flinked_bo);
> gem_close(fd2, flinked_bo);
>
> - igt_drop_caches_set(DROP_RETIRE);
> + igt_drop_caches_set(fd, DROP_RETIRE);
>
> /* the flinked bo VMA should have been cleared now, so a new bo of the
> * same size should get the same offset
> @@ -269,12 +269,12 @@ static void flink_and_exit(void)
> flinked_bo = gem_open(fd2, name);
>
> /* Verify VMA is not there yet. */
> - igt_assert(!igt_debugfs_search("i915_gem_gtt", match));
> + igt_assert(!igt_debugfs_search(fd, "i915_gem_gtt", match));
>
> exec_and_get_offset(fd2, flinked_bo);
>
> /* Verify VMA has been created. */
> - igt_assert(igt_debugfs_search("i915_gem_gtt", match));
> + igt_assert(igt_debugfs_search(fd, "i915_gem_gtt", match));
>
> /* Close the context. */
> close(fd2);
> @@ -286,8 +286,8 @@ static void flink_and_exit(void)
> exec_and_get_offset(fd3, gem_create(fd3, 4096));
> close(fd3);
>
> - igt_drop_caches_set(DROP_ACTIVE | DROP_RETIRE);
> - igt_assert(!igt_debugfs_search("i915_gem_gtt", match));
> + igt_drop_caches_set(fd, DROP_ACTIVE | DROP_RETIRE);
> + igt_assert(!igt_debugfs_search(fd, "i915_gem_gtt", match));
>
> close(fd);
> }
> diff --git a/tests/gem_reloc_vs_gpu.c b/tests/gem_reloc_vs_gpu.c
> index fa4d9aa36d80..afc31328fdc2 100644
> --- a/tests/gem_reloc_vs_gpu.c
> +++ b/tests/gem_reloc_vs_gpu.c
> @@ -265,7 +265,7 @@ static void do_forked_test(int fd, unsigned flags)
> igt_fork_helper(&thrasher) {
> while (1) {
> usleep(1000);
> - igt_drop_caches_set(val);
> + igt_drop_caches_set(fd, val);
> }
> }
> }
> diff --git a/tests/gem_seqno_wrap.c b/tests/gem_seqno_wrap.c
> index 3b0cc3a866b7..2270dfa22f93 100644
> --- a/tests/gem_seqno_wrap.c
> +++ b/tests/gem_seqno_wrap.c
> @@ -47,6 +47,7 @@
> IGT_TEST_DESCRIPTION("Runs blitcopy -> rendercopy with multiple
buffers over"
> " wrap boundary.");
>
> +static int drm_fd;
> static int devid;
> static int card_index = 0;
> static uint32_t last_seqno = 0;
> @@ -174,26 +175,25 @@ static void run_sync_test(int num_buffers, bool
verify)
> int max;
> drm_intel_bo **src, **dst1, **dst2;
> int width = 128, height = 128;
> - int fd;
> int i;
> unsigned int *p_dst1, *p_dst2;
> struct igt_buf *s_src, *s_dst;
>
> - fd = drm_open_driver(DRIVER_INTEL);
> + drm_fd = drm_open_driver(DRIVER_INTEL);
>
> - gem_quiescent_gpu(fd);
> + gem_quiescent_gpu(drm_fd);
>
> - devid = intel_get_drm_devid(fd);
> + devid = intel_get_drm_devid(drm_fd);
>
> - max = gem_aperture_size (fd) / (1024 * 1024) / 2;
> + max = gem_aperture_size (drm_fd) / (1024 * 1024) / 2;
> if (num_buffers > max)
> num_buffers = max;
>
> - bufmgr = drm_intel_bufmgr_gem_init(fd, 4096);
> + bufmgr = drm_intel_bufmgr_gem_init(drm_fd, 4096);
> drm_intel_bufmgr_gem_enable_reuse(bufmgr);
> - batch_blt = intel_batchbuffer_alloc(bufmgr, intel_get_drm_devid(fd));
> + batch_blt = intel_batchbuffer_alloc(bufmgr,
intel_get_drm_devid(drm_fd));
> igt_assert(batch_blt);
> - batch_3d = intel_batchbuffer_alloc(bufmgr, intel_get_drm_devid(fd));
> + batch_3d = intel_batchbuffer_alloc(bufmgr,
intel_get_drm_devid(drm_fd));
> igt_assert(batch_3d);
>
> src = malloc(num_buffers * sizeof(*src));
> @@ -265,9 +265,9 @@ static void run_sync_test(int num_buffers, bool
verify)
> free(dst1);
> free(src);
>
> - gem_quiescent_gpu(fd);
> + gem_quiescent_gpu(drm_fd);
>
> - close(fd);
> + close(drm_fd);
> }
>
> static int __read_seqno(uint32_t *seqno)
> @@ -278,7 +278,7 @@ static int __read_seqno(uint32_t *seqno)
> char *p;
> unsigned long int tmp;
>
> - fh = igt_debugfs_open("i915_next_seqno", O_RDONLY);
> + fh = igt_debugfs_open(drm_fd, "i915_next_seqno", O_RDONLY);
>
> r = read(fh, buf, sizeof(buf) - 1);
> close(fh);
> @@ -332,7 +332,7 @@ static void write_seqno(uint32_t seqno)
> if (options.dontwrap)
> return;
>
> - fd = igt_debugfs_open("i915_next_seqno", O_RDWR);
> + fd = igt_debugfs_open(drm_fd, "i915_next_seqno", O_RDWR);
> len = snprintf(buf, sizeof(buf), "0x%x", seqno);
> igt_assert(write(fd, buf, len) == len);
> close(fd);
> diff --git a/tests/gem_tiled_swapping.c b/tests/gem_tiled_swapping.c
> index b5849bc1a5ee..dacbb6900099 100644
> --- a/tests/gem_tiled_swapping.c
> +++ b/tests/gem_tiled_swapping.c
> @@ -155,9 +155,9 @@ static void thread_fini(struct thread *t)
> free(t->idx_arr);
> }
>
> -static void check_memory_layout(void)
> +static void check_memory_layout(int fd)
> {
> - igt_skip_on_f(igt_debugfs_search("i915_swizzle_info", "L-shaped"),
> + igt_skip_on_f(igt_debugfs_search(fd, "i915_swizzle_info", "L-shaped"),
> "L-shaped memory configuration detected\n");
>
> igt_debug("normal memory configuration detected, continuing\n");
> @@ -177,7 +177,7 @@ igt_main
>
> fd = drm_open_driver(DRIVER_INTEL);
>
> - check_memory_layout();
> + check_memory_layout(fd);
>
> /* lock RAM, leaving only 512MB available */
> lock_size = max(0, intel_get_total_ram_mb() - AVAIL_RAM);
> diff --git a/tests/gem_workarounds.c b/tests/gem_workarounds.c
> index e512dd3d5d8a..08a1d09af451 100644
> --- a/tests/gem_workarounds.c
> +++ b/tests/gem_workarounds.c
> @@ -133,9 +133,9 @@ igt_main
> pci_dev = intel_get_pci_device();
> igt_require(pci_dev);
>
> - intel_register_access_init(pci_dev, 0);
> + intel_register_access_init(pci_dev, 0, fd);
>
> - file = igt_debugfs_fopen("i915_wa_registers", "r");
> + file = igt_debugfs_fopen(fd, "i915_wa_registers", "r");
> igt_assert(getline(&line, &line_size, file) > 0);
> igt_debug("i915_wa_registers: %s", line);
> sscanf(line, "Workarounds applied: %d", &num_wa_regs);
> diff --git a/tests/kms_atomic_transition.c
b/tests/kms_atomic_transition.c
> index a8ab1b7b4d7a..70bff203ff3c 100644
> --- a/tests/kms_atomic_transition.c
> +++ b/tests/kms_atomic_transition.c
> @@ -675,7 +675,7 @@ static void run_modeset_tests(igt_display_t
*display, int howmany, bool nonblock
> drmModeModeInfo *mode = NULL;
>
> if (is_i915_device(display->drm_fd))
> - pipe_crcs[i] = igt_pipe_crc_new(i, INTEL_PIPE_CRC_SOURCE_AUTO);
> + pipe_crcs[i] = igt_pipe_crc_new(display->drm_fd, i,
INTEL_PIPE_CRC_SOURCE_AUTO);
>
> for_each_valid_output_on_pipe(display, i, output) {
> if (output->pending_crtc_idx_mask)
> diff --git a/tests/kms_ccs.c b/tests/kms_ccs.c
> index 11acda89c3d6..d8291520c8a6 100644
> --- a/tests/kms_ccs.c
> +++ b/tests/kms_ccs.c
> @@ -212,7 +212,7 @@ static void test_output(data_t *data)
> igt_output_set_pipe(data->output, data->pipe);
>
> if (data->flags & TEST_CRC) {
> - pipe_crc = igt_pipe_crc_new(data->pipe, INTEL_PIPE_CRC_SOURCE_AUTO);
> + pipe_crc = igt_pipe_crc_new(data->drm_fd, data->pipe,
INTEL_PIPE_CRC_SOURCE_AUTO);
>
> display_fb(data, TEST_COMPRESSED);
> igt_pipe_crc_collect_crc(pipe_crc, &ref_crc);
> @@ -276,7 +276,7 @@ igt_main
>
> igt_require(intel_gen(intel_get_drm_devid(data.drm_fd)) >= 9);
> kmstest_set_vt_graphics_mode();
> - igt_require_pipe_crc();
> + igt_require_pipe_crc(data.drm_fd);
>
> igt_display_init(&data.display, data.drm_fd);
> }
> diff --git a/tests/kms_chv_cursor_fail.c b/tests/kms_chv_cursor_fail.c
> index ce6e8df69400..3e74df1142da 100644
> --- a/tests/kms_chv_cursor_fail.c
> +++ b/tests/kms_chv_cursor_fail.c
> @@ -254,7 +254,7 @@ static void prepare_crtc(data_t *data)
> if (data->pipe_crc)
> igt_pipe_crc_free(data->pipe_crc);
>
> - data->pipe_crc = igt_pipe_crc_new_nonblock(data->pipe,
> + data->pipe_crc = igt_pipe_crc_new_nonblock(data->drm_fd, data->pipe,
> INTEL_PIPE_CRC_SOURCE_AUTO);
>
> /* make sure cursor is disabled */
> @@ -374,7 +374,7 @@ int main(int argc, char **argv)
>
> kmstest_set_vt_graphics_mode();
>
> - igt_require_pipe_crc();
> + igt_require_pipe_crc(data.drm_fd);
>
> igt_display_init(&data.display, data.drm_fd);
> }
> diff --git a/tests/kms_crtc_background_color.c
b/tests/kms_crtc_background_color.c
> index d6dd8d9098ea..e12e163449f8 100644
> --- a/tests/kms_crtc_background_color.c
> +++ b/tests/kms_crtc_background_color.c
> @@ -85,7 +85,7 @@ static void prepare_crtc(data_t *data, igt_output_t
*output, enum pipe pipe,
>
> /* create the pipe_crc object for this pipe */
> igt_pipe_crc_free(data->pipe_crc);
> - data->pipe_crc = igt_pipe_crc_new(pipe, INTEL_PIPE_CRC_SOURCE_AUTO);
> + data->pipe_crc = igt_pipe_crc_new(data->gfx_fd, pipe,
INTEL_PIPE_CRC_SOURCE_AUTO);
>
> mode = igt_output_get_mode(output);
>
> @@ -179,7 +179,7 @@ igt_simple_main
> igt_skip_on_simulation();
>
> data.gfx_fd = drm_open_driver(DRIVER_INTEL);
> - igt_require_pipe_crc();
> + igt_require_pipe_crc(data.gfx_fd);
> igt_display_init(&data.display, data.gfx_fd);
>
> test_crtc_background(&data);
> diff --git a/tests/kms_cursor_crc.c b/tests/kms_cursor_crc.c
> index 4851e18f457d..206f85268c9e 100644
> --- a/tests/kms_cursor_crc.c
> +++ b/tests/kms_cursor_crc.c
> @@ -310,7 +310,7 @@ static void prepare_crtc(data_t *data,
igt_output_t *output,
> if (data->pipe_crc)
> igt_pipe_crc_free(data->pipe_crc);
>
> - data->pipe_crc = igt_pipe_crc_new(data->pipe,
> + data->pipe_crc = igt_pipe_crc_new(data->drm_fd, data->pipe,
> INTEL_PIPE_CRC_SOURCE_AUTO);
>
> /* x/y position where the cursor is still fully visible */
> @@ -602,7 +602,7 @@ igt_main
>
> kmstest_set_vt_graphics_mode();
>
> - igt_require_pipe_crc();
> + igt_require_pipe_crc(data.drm_fd);
>
> igt_display_init(&data.display, data.drm_fd);
> }
> diff --git a/tests/kms_cursor_legacy.c b/tests/kms_cursor_legacy.c
> index c7083a070f27..92f8e5f304ce 100644
> --- a/tests/kms_cursor_legacy.c
> +++ b/tests/kms_cursor_legacy.c
> @@ -1264,7 +1264,7 @@ static void flip_vs_cursor_crc(igt_display_t
*display, bool atomic)
>
> igt_display_commit2(display, display->is_atomic ? COMMIT_ATOMIC :
COMMIT_LEGACY);
>
> - pipe_crc = igt_pipe_crc_new(pipe, INTEL_PIPE_CRC_SOURCE_AUTO);
> + pipe_crc = igt_pipe_crc_new(display->drm_fd, pipe,
INTEL_PIPE_CRC_SOURCE_AUTO);
>
> set_cursor_on_pipe(display, pipe, &cursor_fb);
> igt_display_commit2(display, COMMIT_UNIVERSAL);
> @@ -1326,7 +1326,7 @@ static void
flip_vs_cursor_busy_crc(igt_display_t *display, bool atomic)
>
> igt_display_commit2(display, display->is_atomic ? COMMIT_ATOMIC :
COMMIT_LEGACY);
>
> - pipe_crc = igt_pipe_crc_new(pipe, INTEL_PIPE_CRC_SOURCE_AUTO);
> + pipe_crc = igt_pipe_crc_new(display->drm_fd, pipe,
INTEL_PIPE_CRC_SOURCE_AUTO);
>
> set_cursor_on_pipe(display, pipe, &cursor_fb);
> igt_display_commit2(display, COMMIT_UNIVERSAL);
> diff --git a/tests/kms_draw_crc.c b/tests/kms_draw_crc.c
> index e1639810ba3a..c57d3a35b6b8 100644
> --- a/tests/kms_draw_crc.c
> +++ b/tests/kms_draw_crc.c
> @@ -232,7 +232,7 @@ static void setup_environment(void)
> drm_intel_bufmgr_gem_enable_reuse(bufmgr);
>
> find_modeset_params();
> - pipe_crc = igt_pipe_crc_new(kmstest_get_crtc_idx(drm_res, ms.crtc_id),
> + pipe_crc = igt_pipe_crc_new(drm_fd, kmstest_get_crtc_idx(drm_res,
ms.crtc_id),
> INTEL_PIPE_CRC_SOURCE_AUTO);
> }
>
> diff --git a/tests/kms_fbc_crc.c b/tests/kms_fbc_crc.c
> index 96af06a04869..7964e052862b 100644
> --- a/tests/kms_fbc_crc.c
> +++ b/tests/kms_fbc_crc.c
> @@ -211,7 +211,7 @@ static bool fbc_enabled(data_t *data)
> {
> char str[128] = {};
>
> - igt_debugfs_read("i915_fbc_status", str);
> + igt_debugfs_read(data->drm_fd, "i915_fbc_status", str);
> return strstr(str, "FBC enabled") != NULL;
> }
>
> @@ -378,7 +378,7 @@ static bool prepare_test(data_t *data, enum
test_mode test_mode)
>
> igt_pipe_crc_free(data->pipe_crc);
> data->pipe_crc = NULL;
> - pipe_crc = igt_pipe_crc_new(data->pipe,
> + pipe_crc = igt_pipe_crc_new(data->drm_fd, data->pipe,
> INTEL_PIPE_CRC_SOURCE_AUTO);
> data->pipe_crc = pipe_crc;
>
> @@ -530,9 +530,9 @@ igt_main
>
> data.devid = intel_get_drm_devid(data.drm_fd);
>
> - igt_require_pipe_crc();
> + igt_require_pipe_crc(data.drm_fd);
>
> - igt_debugfs_read("i915_fbc_status", buf);
> + igt_debugfs_read(data.drm_fd, "i915_fbc_status", buf);
> igt_require_f(!strstr(buf, "unsupported on this chipset"),
> "FBC not supported\n");
>
> diff --git a/tests/kms_fbcon_fbt.c b/tests/kms_fbcon_fbt.c
> index 6342289f765b..d0090912694e 100644
> --- a/tests/kms_fbcon_fbt.c
> +++ b/tests/kms_fbcon_fbt.c
> @@ -82,11 +82,11 @@ static void teardown_drm(struct drm_info *drm)
> igt_assert(close(drm->fd) == 0);
> }
>
> -static bool fbc_supported_on_chipset(void)
> +static bool fbc_supported_on_chipset(int fd)
> {
> char buf[128];
>
> - igt_debugfs_read("i915_fbc_status", buf);
> + igt_debugfs_read(fd, "i915_fbc_status", buf);
> return !strstr(buf, "FBC unsupported on this chipset\n");
> }
>
> @@ -95,17 +95,17 @@ static bool connector_can_fbc(drmModeConnectorPtr
connector)
> return true;
> }
>
> -static bool fbc_is_enabled(void)
> +static bool fbc_is_enabled(int fd)
> {
> char buf[128];
>
> - igt_debugfs_read("i915_fbc_status", buf);
> + igt_debugfs_read(fd, "i915_fbc_status", buf);
> return strstr(buf, "FBC enabled\n");
> }
>
> -static bool fbc_wait_until_enabled(void)
> +static bool fbc_wait_until_enabled(int fd)
> {
> - return igt_wait(fbc_is_enabled(), 5000, 1);
> + return igt_wait(fbc_is_enabled(fd), 5000, 1);
> }
>
> typedef bool (*connector_possible_fn)(drmModeConnectorPtr connector);
> @@ -147,11 +147,11 @@ static void set_mode_for_one_screen(struct
drm_info *drm, struct igt_fb *fb,
> igt_assert_eq(rc, 0);
> }
>
> -static bool psr_supported_on_chipset(void)
> +static bool psr_supported_on_chipset(int fd)
> {
> char buf[256];
>
> - igt_debugfs_read("i915_edp_psr_status", buf);
> + igt_debugfs_read(fd, "i915_edp_psr_status", buf);
> return strstr(buf, "Sink_Support: yes\n");
> }
>
> @@ -160,22 +160,22 @@ static bool
connector_can_psr(drmModeConnectorPtr connector)
> return (connector->connector_type == DRM_MODE_CONNECTOR_eDP);
> }
>
> -static bool psr_is_enabled(void)
> +static bool psr_is_enabled(int fd)
> {
> char buf[256];
>
> - igt_debugfs_read("i915_edp_psr_status", buf);
> + igt_debugfs_read(fd, "i915_edp_psr_status", buf);
> return strstr(buf, "\nActive: yes\n");
> }
>
> -static bool psr_wait_until_enabled(void)
> +static bool psr_wait_until_enabled(int fd)
> {
> - return igt_wait(psr_is_enabled(), 5000, 1);
> + return igt_wait(psr_is_enabled(fd), 5000, 1);
> }
>
> struct feature {
> - bool (*supported_on_chipset)(void);
> - bool (*wait_until_enabled)(void);
> + bool (*supported_on_chipset)(int fd);
> + bool (*wait_until_enabled)(int fd);
> bool (*connector_possible_fn)(drmModeConnectorPtr connector);
> const char *param_name;
> } fbc = {
> @@ -201,26 +201,26 @@ static void subtest(struct feature *feature,
bool suspend)
> struct drm_info drm;
> struct igt_fb fb;
>
> - igt_require(feature->supported_on_chipset());
> + setup_drm(&drm);
> +
> + igt_require(feature->supported_on_chipset(drm.fd));
>
> disable_features();
> igt_set_module_param_int(feature->param_name, 1);
>
> - setup_drm(&drm);
> -
> kmstest_unset_all_crtcs(drm.fd, drm.res);
> wait_user("Modes unset.");
> - igt_assert(!feature->wait_until_enabled());
> + igt_assert(!feature->wait_until_enabled(drm.fd));
>
> set_mode_for_one_screen(&drm, &fb, feature->connector_possible_fn);
> wait_user("Screen set.");
> - igt_assert(feature->wait_until_enabled());
> + igt_assert(feature->wait_until_enabled(drm.fd));
>
> if (suspend) {
> igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
> SUSPEND_TEST_NONE);
> sleep(5);
> - igt_assert(feature->wait_until_enabled());
> + igt_assert(feature->wait_until_enabled(drm.fd));
> }
>
> igt_remove_fb(drm.fd, &fb);
> @@ -230,13 +230,13 @@ static void subtest(struct feature *feature,
bool suspend)
> sleep(3);
>
> wait_user("Back to fbcon.");
> - igt_assert(!feature->wait_until_enabled());
> + igt_assert(!feature->wait_until_enabled(drm.fd));
>
> if (suspend) {
> igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
> SUSPEND_TEST_NONE);
> sleep(5);
> - igt_assert(!feature->wait_until_enabled());
> + igt_assert(!feature->wait_until_enabled(drm.fd));
> }
> }
>
> diff --git a/tests/kms_flip_tiling.c b/tests/kms_flip_tiling.c
> index cd2f510f1d45..143be198abe6 100644
> --- a/tests/kms_flip_tiling.c
> +++ b/tests/kms_flip_tiling.c
> @@ -41,14 +41,14 @@ typedef struct {
>
> static igt_pipe_crc_t *_pipe_crc;
>
> -static igt_pipe_crc_t *pipe_crc_new(int pipe)
> +static igt_pipe_crc_t *pipe_crc_new(data_t *data, int pipe)
> {
> if (_pipe_crc) {
> igt_pipe_crc_free(_pipe_crc);
> _pipe_crc = NULL;
> }
>
> - _pipe_crc = igt_pipe_crc_new(pipe, INTEL_PIPE_CRC_SOURCE_AUTO);
> + _pipe_crc = igt_pipe_crc_new(data->drm_fd, pipe,
INTEL_PIPE_CRC_SOURCE_AUTO);
> igt_assert(_pipe_crc);
>
> return _pipe_crc;
> @@ -89,7 +89,7 @@ test_flip_tiling(data_t *data, enum pipe pipe,
igt_output_t *output, uint64_t ti
> igt_crc_t reference_crc, crc;
> int fb_id, ret, width;
>
> - pipe_crc = pipe_crc_new(pipe);
> + pipe_crc = pipe_crc_new(data, pipe);
> igt_output_set_pipe(output, pipe);
>
> mode = igt_output_get_mode(output);
> @@ -168,7 +168,7 @@ igt_main
>
> kmstest_set_vt_graphics_mode();
>
> - igt_require_pipe_crc();
> + igt_require_pipe_crc(data.drm_fd);
> igt_display_init(&data.display, data.drm_fd);
> }
>
> diff --git a/tests/kms_frontbuffer_tracking.c
b/tests/kms_frontbuffer_tracking.c
> index 03c77107eccd..28e4b5b1abec 100644
> --- a/tests/kms_frontbuffer_tracking.c
> +++ b/tests/kms_frontbuffer_tracking.c
> @@ -781,7 +781,7 @@ static bool fbc_is_enabled(void)
> {
> char buf[128];
>
> - igt_debugfs_read("i915_fbc_status", buf);
> + igt_debugfs_read(drm.fd, "i915_fbc_status", buf);
> return strstr(buf, "FBC enabled\n");
> }
>
> @@ -789,7 +789,7 @@ static void fbc_print_status(void)
> {
> char buf[128];
>
> - igt_debugfs_read("i915_fbc_status", buf);
> + igt_debugfs_read(drm.fd, "i915_fbc_status", buf);
> igt_info("FBC status:\n%s\n", buf);
> }
>
> @@ -797,7 +797,7 @@ static bool psr_is_enabled(void)
> {
> char buf[256];
>
> - igt_debugfs_read("i915_edp_psr_status", buf);
> + igt_debugfs_read(drm.fd, "i915_edp_psr_status", buf);
> return strstr(buf, "\nActive: yes\n") &&
> strstr(buf, "\nHW Enabled & Active bit: yes\n");
> }
> @@ -806,7 +806,7 @@ static void psr_print_status(void)
> {
> char buf[256];
>
> - igt_debugfs_read("i915_edp_psr_status", buf);
> + igt_debugfs_read(drm.fd, "i915_edp_psr_status", buf);
> igt_info("PSR status:\n%s\n", buf);
> }
>
> @@ -817,7 +817,7 @@ static struct timespec fbc_get_last_action(void)
> char *action;
> ssize_t n_read;
>
> - igt_debugfs_read("i915_fbc_status", buf);
> + igt_debugfs_read(drm.fd, "i915_fbc_status", buf);
>
> action = strstr(buf, "\nLast action:");
> igt_assert(action);
> @@ -866,7 +866,7 @@ static void fbc_setup_last_action(void)
> char buf[128];
> char *action;
>
> - igt_debugfs_read("i915_fbc_status", buf);
> + igt_debugfs_read(drm.fd, "i915_fbc_status", buf);
>
> action = strstr(buf, "\nLast action:");
> if (!action) {
> @@ -885,7 +885,7 @@ static bool fbc_is_compressing(void)
> {
> char buf[128];
>
> - igt_debugfs_read("i915_fbc_status", buf);
> + igt_debugfs_read(drm.fd, "i915_fbc_status", buf);
> return strstr(buf, "\nCompressing: yes\n") != NULL;
> }
>
> @@ -898,7 +898,7 @@ static bool fbc_not_enough_stolen(void)
> {
> char buf[128];
>
> - igt_debugfs_read("i915_fbc_status", buf);
> + igt_debugfs_read(drm.fd, "i915_fbc_status", buf);
> return strstr(buf, "FBC disabled: not enough stolen memory\n");
> }
>
> @@ -906,7 +906,7 @@ static bool fbc_stride_not_supported(void)
> {
> char buf[128];
>
> - igt_debugfs_read("i915_fbc_status", buf);
> + igt_debugfs_read(drm.fd, "i915_fbc_status", buf);
> return strstr(buf, "FBC disabled: framebuffer stride not supported\n");
> }
>
> @@ -1420,7 +1420,7 @@ static void setup_sink_crc(void)
> fill_fb_region(&prim_mode_params.fb, COLOR_PRIM_BG);
> set_mode_for_params(&prim_mode_params);
>
> - sink_crc.fd = igt_debugfs_open("i915_sink_crc_eDP1", O_RDONLY);
> + sink_crc.fd = igt_debugfs_open(drm.fd, "i915_sink_crc_eDP1", O_RDONLY);
> igt_assert_lte(0, sink_crc.fd);
>
> /* Do a first read to try to detect if it's supported. */
> @@ -1432,7 +1432,7 @@ static void setup_crcs(void)
> enum pixel_format f;
> int crtc_idx = kmstest_get_crtc_idx(drm.res, prim_mode_params.crtc_id);
>
> - pipe_crc = igt_pipe_crc_new(crtc_idx, INTEL_PIPE_CRC_SOURCE_AUTO);
> + pipe_crc = igt_pipe_crc_new(drm.fd, crtc_idx,
INTEL_PIPE_CRC_SOURCE_AUTO);
>
> setup_sink_crc();
>
> @@ -1497,7 +1497,7 @@ static bool fbc_supported_on_chipset(void)
> {
> char buf[128];
>
> - igt_debugfs_read("i915_fbc_status", buf);
> + igt_debugfs_read(drm.fd, "i915_fbc_status", buf);
> return !strstr(buf, "FBC unsupported on this chipset\n");
> }
>
> @@ -1533,7 +1533,7 @@ static bool psr_sink_has_support(void)
> {
> char buf[256];
>
> - igt_debugfs_read("i915_edp_psr_status", buf);
> + igt_debugfs_read(drm.fd, "i915_edp_psr_status", buf);
> return strstr(buf, "Sink_Support: yes\n");
> }
>
> diff --git a/tests/kms_invalid_dotclock.c b/tests/kms_invalid_dotclock.c
> index 43f768fd26ea..e6e72f528d85 100644
> --- a/tests/kms_invalid_dotclock.c
> +++ b/tests/kms_invalid_dotclock.c
> @@ -104,13 +104,13 @@ static void test(data_t *data)
> igt_require_f(valid_connectors, "No suitable connectors found\n");
> }
>
> -static int i915_max_dotclock(void)
> +static int i915_max_dotclock(data_t *data)
> {
> char buf[4096];
> char *s;
> int max_dotclock = 0;
>
> - igt_debugfs_read("i915_frequency_info", buf);
> + igt_debugfs_read(data->drm_fd, "i915_frequency_info", buf);
> s = strstr(buf, "Max pixel clock frequency:");
> igt_assert(s);
> igt_assert_eq(sscanf(s, "Max pixel clock frequency: %d kHz",
&max_dotclock), 1);
> @@ -137,7 +137,7 @@ igt_simple_main
> data.res = drmModeGetResources(data.drm_fd);
> kmstest_unset_all_crtcs(data.drm_fd, data.res);
>
> - data.max_dotclock = i915_max_dotclock();
> + data.max_dotclock = i915_max_dotclock(&data);
> igt_info("Max dotclock: %d kHz\n", data.max_dotclock);
>
> test(&data);
> diff --git a/tests/kms_mmap_write_crc.c b/tests/kms_mmap_write_crc.c
> index 8a1331ccfbcd..e5f089f6b78f 100644
> --- a/tests/kms_mmap_write_crc.c
> +++ b/tests/kms_mmap_write_crc.c
> @@ -185,7 +185,7 @@ static void prepare_crtc(data_t *data)
> if (data->pipe_crc)
> igt_pipe_crc_free(data->pipe_crc);
>
> - data->pipe_crc = igt_pipe_crc_new(data->pipe,
> + data->pipe_crc = igt_pipe_crc_new(data->drm_fd, data->pipe,
> INTEL_PIPE_CRC_SOURCE_AUTO);
>
> /* get reference crc for the white fb */
> @@ -277,7 +277,7 @@ int main(int argc, char **argv)
>
> kmstest_set_vt_graphics_mode();
>
> - igt_require_pipe_crc();
> + igt_require_pipe_crc(data.drm_fd);
>
> igt_display_init(&data.display, data.drm_fd);
>
> diff --git a/tests/kms_mmio_vs_cs_flip.c b/tests/kms_mmio_vs_cs_flip.c
> index 09217b310f26..96a9dec3d656 100644
> --- a/tests/kms_mmio_vs_cs_flip.c
> +++ b/tests/kms_mmio_vs_cs_flip.c
> @@ -235,7 +235,7 @@ test_plane(data_t *data, igt_output_t *output,
enum pipe pipe, int plane)
>
> if (data->pipe_crc)
> igt_pipe_crc_free(data->pipe_crc);
> - data->pipe_crc = igt_pipe_crc_new(pipe, INTEL_PIPE_CRC_SOURCE_AUTO);
> + data->pipe_crc = igt_pipe_crc_new(data->drm_fd, pipe,
INTEL_PIPE_CRC_SOURCE_AUTO);
>
> /* set red fb and grab reference crc */
> igt_plane_set_fb(primary, &red_fb);
> @@ -374,7 +374,7 @@ test_crtc(data_t *data, igt_output_t *output,
enum pipe pipe)
>
> if (data->pipe_crc)
> igt_pipe_crc_free(data->pipe_crc);
> - data->pipe_crc = igt_pipe_crc_new(pipe, INTEL_PIPE_CRC_SOURCE_AUTO);
> + data->pipe_crc = igt_pipe_crc_new(data->drm_fd, pipe,
INTEL_PIPE_CRC_SOURCE_AUTO);
>
> /* set red fb and grab reference crc */
> igt_plane_set_fb(primary, &red_fb);
> @@ -497,7 +497,7 @@ igt_main
>
> data.devid = intel_get_drm_devid(data.drm_fd);
>
> - igt_require_pipe_crc();
> + igt_require_pipe_crc(data.drm_fd);
> igt_display_init(&data.display, data.drm_fd);
>
> data.bufmgr = drm_intel_bufmgr_gem_init(data.drm_fd, 4096);
> diff --git a/tests/kms_pipe_color.c b/tests/kms_pipe_color.c
> index c7a5d2f1a81e..fd58ac8118c2 100644
> --- a/tests/kms_pipe_color.c
> +++ b/tests/kms_pipe_color.c
> @@ -852,7 +852,7 @@ run_tests_for_pipe(data_t *data, enum pipe p)
> igt_fixture {
> int valid_tests = 0;
>
> - igt_require_pipe_crc();
> + igt_require_pipe_crc(data->drm_fd);
>
> igt_require(p < data->display.n_pipes);
>
> @@ -861,7 +861,8 @@ run_tests_for_pipe(data_t *data, enum pipe p)
>
> primary = igt_pipe_get_plane_type(pipe, DRM_PLANE_TYPE_PRIMARY);
>
> - data->pipe_crc = igt_pipe_crc_new(primary->pipe->pipe,
> + data->pipe_crc = igt_pipe_crc_new(data->drm_fd,
> + primary->pipe->pipe,
> INTEL_PIPE_CRC_SOURCE_AUTO);
>
> igt_require(igt_pipe_get_property(&data->display.pipes[p],
> diff --git a/tests/kms_pipe_crc_basic.c b/tests/kms_pipe_crc_basic.c
> index dd2ad3c366bc..d0dc2a1b58cf 100644
> --- a/tests/kms_pipe_crc_basic.c
> +++ b/tests/kms_pipe_crc_basic.c
> @@ -48,7 +48,7 @@ static void test_bad_command(data_t *data, const
char *cmd)
> FILE *ctl;
> size_t written;
>
> - ctl = igt_debugfs_fopen("i915_display_crc_ctl", "r+");
> + ctl = igt_debugfs_fopen(data->drm_fd, "i915_display_crc_ctl", "r+");
> igt_require(ctl);
>
> written = fwrite(cmd, 1, strlen(cmd), ctl);
> @@ -66,7 +66,7 @@ static void test_bad_source(data_t *data)
> size_t written;
> const char *source = "foo";
>
> - f = igt_debugfs_fopen("crtc-0/crc/control", "w");
> + f = igt_debugfs_fopen(data->drm_fd, "crtc-0/crc/control", "w");
> if (!f) {
> test_bad_command(data, "pipe A foo");
> return;
> @@ -79,7 +79,7 @@ static void test_bad_source(data_t *data)
> igt_assert(!errno);
> fclose(f);
>
> - f = igt_debugfs_fopen("crtc-0/crc/data", "w");
> + f = igt_debugfs_fopen(data->drm_fd, "crtc-0/crc/data", "w");
> igt_assert(!f);
> igt_assert_eq(errno, EINVAL);
> }
> @@ -125,9 +125,9 @@ test_read_crc_for_output(data_t *data, int pipe,
igt_output_t *output,
> igt_display_commit(display);
>
> if (flags & TEST_NONBLOCK)
> - pipe_crc = igt_pipe_crc_new_nonblock(pipe,
INTEL_PIPE_CRC_SOURCE_AUTO);
> + pipe_crc = igt_pipe_crc_new_nonblock(data->drm_fd, pipe,
INTEL_PIPE_CRC_SOURCE_AUTO);
> else
> - pipe_crc = igt_pipe_crc_new(pipe, INTEL_PIPE_CRC_SOURCE_AUTO);
> + pipe_crc = igt_pipe_crc_new(data->drm_fd, pipe,
INTEL_PIPE_CRC_SOURCE_AUTO);
>
> igt_pipe_crc_start(pipe_crc);
>
> @@ -210,7 +210,7 @@ igt_main
>
> kmstest_set_vt_graphics_mode();
>
> - igt_require_pipe_crc();
> + igt_require_pipe_crc(data.drm_fd);
>
> igt_display_init(&data.display, data.drm_fd);
> }
> diff --git a/tests/kms_plane.c b/tests/kms_plane.c
> index d0de0f52fce4..e1bd467bb97d 100644
> --- a/tests/kms_plane.c
> +++ b/tests/kms_plane.c
> @@ -52,7 +52,7 @@ static color_t blue = { 0.0f, 0.0f, 1.0f };
> */
> static void test_init(data_t *data, enum pipe pipe)
> {
> - data->pipe_crc = igt_pipe_crc_new(pipe, INTEL_PIPE_CRC_SOURCE_AUTO);
> + data->pipe_crc = igt_pipe_crc_new(data->drm_fd, pipe,
INTEL_PIPE_CRC_SOURCE_AUTO);
> }
>
> static void test_fini(data_t *data)
> @@ -430,7 +430,7 @@ igt_main
>
> kmstest_set_vt_graphics_mode();
>
> - igt_require_pipe_crc();
> + igt_require_pipe_crc(data.drm_fd);
> igt_display_init(&data.display, data.drm_fd);
> }
>
> diff --git a/tests/kms_plane_lowres.c b/tests/kms_plane_lowres.c
> index 689c248ed309..6f1596015d76 100644
> --- a/tests/kms_plane_lowres.c
> +++ b/tests/kms_plane_lowres.c
> @@ -112,7 +112,7 @@ get_lowres_mode(int drmfd, drmModeModeInfo
*mode_default)
> static void
> test_init(data_t *data, enum pipe pipe)
> {
> - data->pipe_crc = igt_pipe_crc_new(pipe, INTEL_PIPE_CRC_SOURCE_AUTO);
> + data->pipe_crc = igt_pipe_crc_new(data->drm_fd, pipe,
INTEL_PIPE_CRC_SOURCE_AUTO);
> data->plane = calloc(data->display.pipes[pipe].n_planes,
sizeof(data->plane));\
> igt_assert_f(data->plane, "Failed to allocate memory for %d planes\n",
> data->display.pipes[pipe].n_planes);
> @@ -189,11 +189,9 @@ test_setup(data_t *data, enum pipe pipe,
uint64_t modifier, int flags,
> int size;
> int i, x, y;
>
> - crtc.planes = calloc(sizeof(struct kmstest_plane),
data->display.pipes[pipe].n_planes);
> - igt_assert_f(crtc.planes, "Failed to allocate memory for %d
planes\n", data->display.pipes[pipe].n_planes);
> igt_output_set_pipe(output, pipe);
>
> - kmstest_get_crtc(pipe, &crtc);
> + kmstest_get_crtc(data->drm_fd, pipe, &crtc);
> igt_skip_on(crtc.n_planes > data->display.pipes[pipe].n_planes);
> igt_skip_on(crtc.n_planes == 0);
>
> @@ -263,7 +261,7 @@ test_plane_position_with_output(data_t *data,
enum pipe pipe,
> n = igt_pipe_crc_get_crcs(data->pipe_crc, 1, &crc_hires1);
> igt_assert_eq(1, n);
>
> - igt_assert_plane_visible(pipe, true);
> + igt_assert_plane_visible(data->drm_fd, pipe, true);
>
> /* switch to lower resolution */
> igt_output_override_mode(output, &mode_lowres);
> @@ -275,7 +273,7 @@ test_plane_position_with_output(data_t *data,
enum pipe pipe,
>
> display_commit_mode(data, pipe, flags, crc_lowres);
>
> - igt_assert_plane_visible(pipe, false);
> + igt_assert_plane_visible(data->drm_fd, pipe, false);
>
> /* switch back to higher resolution */
> igt_output_override_mode(output, NULL);
> @@ -287,7 +285,7 @@ test_plane_position_with_output(data_t *data,
enum pipe pipe,
>
> display_commit_mode(data, pipe, flags, crc_hires2);
>
> - igt_assert_plane_visible(pipe, true);
> + igt_assert_plane_visible(data->drm_fd, pipe, true);
>
> igt_pipe_crc_stop(data->pipe_crc);
>
> @@ -348,7 +346,7 @@ igt_main
>
> kmstest_set_vt_graphics_mode();
>
> - igt_require_pipe_crc();
> + igt_require_pipe_crc(data.drm_fd);
> igt_display_init(&data.display, data.drm_fd);
> }
>
> diff --git a/tests/kms_plane_multiple.c b/tests/kms_plane_multiple.c
> index 4930286c9190..93dce6b02340 100644
> --- a/tests/kms_plane_multiple.c
> +++ b/tests/kms_plane_multiple.c
> @@ -72,7 +72,7 @@ struct {
> */
> static void test_init(data_t *data, enum pipe pipe, int n_planes)
> {
> - data->pipe_crc = igt_pipe_crc_new(pipe, INTEL_PIPE_CRC_SOURCE_AUTO);
> + data->pipe_crc = igt_pipe_crc_new(data->drm_fd, pipe,
INTEL_PIPE_CRC_SOURCE_AUTO);
>
> data->plane = calloc(n_planes, sizeof(data->plane));
> igt_assert_f(data->plane != NULL, "Failed to allocate memory for
planes\n");
> @@ -508,7 +508,7 @@ int main(int argc, char *argv[])
> igt_fixture {
> data.drm_fd = drm_open_driver_master(DRIVER_INTEL);
> kmstest_set_vt_graphics_mode();
> - igt_require_pipe_crc();
> + igt_require_pipe_crc(data.drm_fd);
> igt_display_init(&data.display, data.drm_fd);
> igt_require(data.display.n_pipes > 0);
> }
> diff --git a/tests/kms_plane_scaling.c b/tests/kms_plane_scaling.c
> index 18ba86c9182e..1457894aaa10 100644
> --- a/tests/kms_plane_scaling.c
> +++ b/tests/kms_plane_scaling.c
> @@ -64,7 +64,7 @@ static void prepare_crtc(data_t *data, igt_output_t
*output, enum pipe pipe,
>
> /* create the pipe_crc object for this pipe */
> igt_pipe_crc_free(data->pipe_crc);
> - data->pipe_crc = igt_pipe_crc_new(pipe, INTEL_PIPE_CRC_SOURCE_AUTO);
> + data->pipe_crc = igt_pipe_crc_new(data->drm_fd, pipe,
INTEL_PIPE_CRC_SOURCE_AUTO);
>
> /* before allocating, free if any older fb */
> if (data->fb_id1) {
> @@ -318,7 +318,7 @@ igt_simple_main
>
>
> data.drm_fd = drm_open_driver(DRIVER_INTEL);
> - igt_require_pipe_crc();
> + igt_require_pipe_crc(data.drm_fd);
> igt_display_init(&data.display, data.drm_fd);
> data.devid = intel_get_drm_devid(data.drm_fd);
>
> diff --git a/tests/kms_psr_sink_crc.c b/tests/kms_psr_sink_crc.c
> index 8f6bdc0d254e..f66a7543ccb6 100644
> --- a/tests/kms_psr_sink_crc.c
> +++ b/tests/kms_psr_sink_crc.c
> @@ -195,7 +195,7 @@ static bool psr_possible(data_t *data)
> {
> char buf[512];
>
> - igt_debugfs_read("i915_edp_psr_status", buf);
> + igt_debugfs_read(data->drm_fd, "i915_edp_psr_status", buf);
>
> return running_with_psr_disabled ||
> strstr(buf, "Sink_Support: yes\n");
> @@ -205,7 +205,7 @@ static bool psr_active(data_t *data)
> {
> char buf[512];
>
> - igt_debugfs_read("i915_edp_psr_status", buf);
> + igt_debugfs_read(data->drm_fd, "i915_edp_psr_status", buf);
>
> return running_with_psr_disabled ||
> strstr(buf, "HW Enabled & Active bit: yes\n");
> @@ -229,7 +229,7 @@ static void get_sink_crc(data_t *data, char *crc) {
> if (igt_interactive_debug)
> return;
>
> - file = igt_debugfs_fopen("i915_sink_crc_eDP1", "r");
> + file = igt_debugfs_fopen(data->drm_fd, "i915_sink_crc_eDP1", "r");
> igt_require(file);
>
> ret = fscanf(file, "%s\n", crc);
> diff --git a/tests/kms_pwrite_crc.c b/tests/kms_pwrite_crc.c
> index 1e62637596ee..ee895db63fe2 100644
> --- a/tests/kms_pwrite_crc.c
> +++ b/tests/kms_pwrite_crc.c
> @@ -124,7 +124,7 @@ static void prepare_crtc(data_t *data)
> if (data->pipe_crc)
> igt_pipe_crc_free(data->pipe_crc);
>
> - data->pipe_crc = igt_pipe_crc_new(data->pipe,
> + data->pipe_crc = igt_pipe_crc_new(data->drm_fd, data->pipe,
> INTEL_PIPE_CRC_SOURCE_AUTO);
>
> /* get reference crc for the white fb */
> @@ -183,7 +183,7 @@ igt_simple_main
>
> kmstest_set_vt_graphics_mode();
>
> - igt_require_pipe_crc();
> + igt_require_pipe_crc(data.drm_fd);
>
> igt_display_init(&data.display, data.drm_fd);
> }
> diff --git a/tests/kms_rotation_crc.c b/tests/kms_rotation_crc.c
> index 9bfcde3324f5..43478849505f 100644
> --- a/tests/kms_rotation_crc.c
> +++ b/tests/kms_rotation_crc.c
> @@ -139,7 +139,7 @@ static void prepare_crtc(data_t *data,
igt_output_t *output, enum pipe pipe,
>
> /* create the pipe_crc object for this pipe */
> igt_pipe_crc_free(data->pipe_crc);
> - data->pipe_crc = igt_pipe_crc_new(pipe, INTEL_PIPE_CRC_SOURCE_AUTO);
> + data->pipe_crc = igt_pipe_crc_new(data->gfx_fd, pipe,
INTEL_PIPE_CRC_SOURCE_AUTO);
>
> mode = igt_output_get_mode(output);
>
> @@ -517,7 +517,7 @@ igt_main
>
> kmstest_set_vt_graphics_mode();
>
> - igt_require_pipe_crc();
> + igt_require_pipe_crc(data.gfx_fd);
>
> igt_display_init(&data.display, data.gfx_fd);
> }
> diff --git a/tests/kms_sink_crc_basic.c b/tests/kms_sink_crc_basic.c
> index 953ead10adf9..f8f814f21442 100644
> --- a/tests/kms_sink_crc_basic.c
> +++ b/tests/kms_sink_crc_basic.c
> @@ -46,11 +46,11 @@ typedef struct {
> igt_plane_t *primary;
> } data_t;
>
> -static void get_crc(char *crc) {
> +static void get_crc(data_t *data, char *crc) {
> int ret;
> FILE *file;
>
> - file = igt_debugfs_fopen("i915_sink_crc_eDP1", "r");
> + file = igt_debugfs_fopen(data->drm_fd, "i915_sink_crc_eDP1", "r");
> igt_require(file);
>
> ret = fscanf(file, "%s\n", crc);
> @@ -95,7 +95,7 @@ static void basic_sink_crc_check(data_t *data)
> igt_display_commit(&data->display);
>
> /* It should be Green */
> - get_crc(crc);
> + get_crc(data, crc);
> assert_color(crc, GREEN);
>
> /* Go Red */
> @@ -103,7 +103,7 @@ static void basic_sink_crc_check(data_t *data)
> igt_display_commit(&data->display);
>
> /* It should be Red */
> - get_crc(crc);
> + get_crc(data, crc);
> assert_color(crc, RED);
> }
>
> diff --git a/tests/kms_universal_plane.c b/tests/kms_universal_plane.c
> index a2fe1cc1be38..991204ceb8a1 100644
> --- a/tests/kms_universal_plane.c
> +++ b/tests/kms_universal_plane.c
> @@ -67,7 +67,7 @@ functional_test_init(functional_test_t *test,
igt_output_t *output, enum pipe pi
> data_t *data = test->data;
> drmModeModeInfo *mode;
>
> - test->pipe_crc = igt_pipe_crc_new(pipe, INTEL_PIPE_CRC_SOURCE_AUTO);
> + test->pipe_crc = igt_pipe_crc_new(data->drm_fd, pipe,
INTEL_PIPE_CRC_SOURCE_AUTO);
>
> igt_output_set_pipe(output, pipe);
>
> @@ -545,13 +545,13 @@ cursor_leak_test_fini(data_t *data,
> }
>
> static int
> -i915_gem_fb_count(void)
> +i915_gem_fb_count(data_t *data)
> {
> char buf[1024];
> FILE *fp;
> int count = 0;
>
> - fp = igt_debugfs_fopen("i915_gem_framebuffer", "r");
> + fp = igt_debugfs_fopen(data->drm_fd, "i915_gem_framebuffer", "r");
> igt_require(fp);
> while (fgets(buf, sizeof(buf), fp) != NULL)
> count++;
> @@ -579,7 +579,7 @@ cursor_leak_test_pipe(data_t *data, enum pipe
pipe, igt_output_t *output)
> mode = igt_output_get_mode(output);
>
> /* Count GEM framebuffers before creating our cursor FB's */
> - count1 = i915_gem_fb_count();
> + count1 = i915_gem_fb_count(data);
>
> /* Black background FB */
> igt_create_color_fb(data->drm_fd, mode->hdisplay, mode->vdisplay,
> @@ -637,7 +637,7 @@ cursor_leak_test_pipe(data_t *data, enum pipe
pipe, igt_output_t *output)
> cursor_leak_test_fini(data, output, &background_fb, cursor_fb);
>
> /* We should be back to the same framebuffer count as when we
started */
> - count2 = i915_gem_fb_count();
> + count2 = i915_gem_fb_count(data);
>
> igt_assert_eq(count1, count2);
> }
> @@ -791,7 +791,7 @@ igt_main
>
> kmstest_set_vt_graphics_mode();
>
> - igt_require_pipe_crc();
> + igt_require_pipe_crc(data.drm_fd);
> igt_display_init(&data.display, data.drm_fd);
> }
>
> diff --git a/tests/perf.c b/tests/perf.c
> index c9c5c57ede90..17925eea72dd 100644
> --- a/tests/perf.c
> +++ b/tests/perf.c
> @@ -297,7 +297,7 @@ sysfs_write(const char *file, uint64_t val)
> }
>
> static char *
> -read_debugfs_record(const char *file, const char *key)
> +read_debugfs_record(int fd, const char *file, const char *key)
> {
> FILE *fp;
> char *line = NULL;
> @@ -306,7 +306,7 @@ read_debugfs_record(const char *file, const char
*key)
> int key_len = strlen(key);
> char *value = NULL;
>
> - fp = igt_debugfs_fopen(file, "r");
> + fp = igt_debugfs_fopen(fd, file, "r");
> igt_require(fp);
>
> while ((len = getline(&line, &line_buf_size, fp)) > 0) {
> @@ -332,9 +332,9 @@ done:
> }
>
> static uint64_t
> -read_debugfs_u64_record(const char *file, const char *key)
> +read_debugfs_u64_record(int fd, const char *file, const char *key)
> {
> - char *str_val = read_debugfs_record(file, key);
> + char *str_val = read_debugfs_record(fd, file, key);
> uint64_t val;
>
> igt_require(str_val);
> @@ -2137,25 +2137,25 @@ test_rc6_disable(void)
> .properties_ptr = to_user_pointer(properties),
> };
> int stream_fd = __perf_open(drm_fd, ¶m);
> - uint64_t n_events_start = read_debugfs_u64_record("i915_drpc_info",
> + uint64_t n_events_start = read_debugfs_u64_record(drm_fd,
"i915_drpc_info",
> "RC6 residency since boot");
> uint64_t n_events_end;
>
> nanosleep(&(struct timespec){ .tv_sec = 0, .tv_nsec = 500000000 },
NULL);
>
> - n_events_end = read_debugfs_u64_record("i915_drpc_info",
> + n_events_end = read_debugfs_u64_record(drm_fd, "i915_drpc_info",
> "RC6 residency since boot");
>
> igt_assert_eq(n_events_end - n_events_start, 0);
>
> close(stream_fd);
>
> - n_events_start = read_debugfs_u64_record("i915_drpc_info",
> + n_events_start = read_debugfs_u64_record(drm_fd, "i915_drpc_info",
> "RC6 residency since boot");
>
> nanosleep(&(struct timespec){ .tv_sec = 0, .tv_nsec = 500000000 },
NULL);
>
> - n_events_end = read_debugfs_u64_record("i915_drpc_info",
> + n_events_end = read_debugfs_u64_record(drm_fd, "i915_drpc_info",
> "RC6 residency since boot");
>
> igt_assert_neq(n_events_end - n_events_start, 0);
> diff --git a/tests/pm_lpsp.c b/tests/pm_lpsp.c
> index bfe5828893d6..a741cb78b007 100644
> --- a/tests/pm_lpsp.c
> +++ b/tests/pm_lpsp.c
> @@ -209,7 +209,7 @@ igt_main
>
> igt_require(supports_lpsp(devid));
>
> - intel_register_access_init(intel_get_pci_device(), 0);
> + intel_register_access_init(intel_get_pci_device(), 0, drm_fd);
>
> kmstest_set_vt_graphics_mode();
> }
> diff --git a/tests/pm_rpm.c b/tests/pm_rpm.c
> index d0600d59dd6b..e5475c911a2f 100644
> --- a/tests/pm_rpm.c
> +++ b/tests/pm_rpm.c
> @@ -657,9 +657,9 @@ static void setup_pc8(void)
> if (!supports_pc8_plus_residencies())
> return;
>
> - pc8_status_fd = igt_debugfs_open("i915_pc8_status", O_RDONLY);
> + pc8_status_fd = igt_debugfs_open(drm_fd, "i915_pc8_status", O_RDONLY);
> if (pc8_status_fd == -1)
> - pc8_status_fd = igt_debugfs_open("i915_runtime_pm_status",
> + pc8_status_fd = igt_debugfs_open(drm_fd, "i915_runtime_pm_status",
> O_RDONLY);
> igt_assert_f(pc8_status_fd >= 0,
> "Can't open /sys/kernel/debug/dri/0/i915_runtime_pm_status");
> @@ -919,7 +919,7 @@ static void debugfs_forcewake_user_subtest(void)
>
> disable_all_screens_and_wait(&ms_data);
>
> - fd = igt_open_forcewake_handle();
> + fd = igt_open_forcewake_handle(drm_fd);
> igt_require(fd >= 0);
>
> if (has_runtime_pm) {
> diff --git a/tests/pm_sseu.c b/tests/pm_sseu.c
> index 3e60a5f86a7b..317bb261ee74 100644
> --- a/tests/pm_sseu.c
> +++ b/tests/pm_sseu.c
> @@ -35,6 +35,19 @@
>
> IGT_TEST_DESCRIPTION("Tests slice/subslice/EU power gating
functionality.\n");
>
> +struct {
> + int init;
> + int drm_fd;
> + int devid;
> + int gen;
> + int has_ppgtt;
> + drm_intel_bufmgr *bufmgr;
> + struct intel_batchbuffer *batch;
> + igt_media_spinfunc_t spinfunc;
> + struct igt_buf buf;
> + uint32_t spins_per_msec;
> +} gem;
> +
> static double
> to_dt(const struct timespec *start, const struct timespec *end)
> {
> @@ -174,7 +187,7 @@ dbg_get_status(struct status *stat)
> static void
> dbg_init(void)
> {
> - dbg.status_fd = igt_debugfs_open("i915_sseu_status", O_RDONLY);
> + dbg.status_fd = igt_debugfs_open(gem.drm_fd, "i915_sseu_status",
O_RDONLY);
> igt_skip_on_f(dbg.status_fd == -1,
> "debugfs entry 'i915_sseu_status' not found\n");
> dbg.init = 1;
> @@ -190,19 +203,6 @@ dbg_deinit(void)
> }
> }
>
> -struct {
> - int init;
> - int drm_fd;
> - int devid;
> - int gen;
> - int has_ppgtt;
> - drm_intel_bufmgr *bufmgr;
> - struct intel_batchbuffer *batch;
> - igt_media_spinfunc_t spinfunc;
> - struct igt_buf buf;
> - uint32_t spins_per_msec;
> -} gem;
> -
> static void
> gem_check_spin(uint32_t spins)
> {
> diff --git a/tests/prime_mmap_kms.c b/tests/prime_mmap_kms.c
> index e7cca54c8029..faace4afd478 100644
> --- a/tests/prime_mmap_kms.c
> +++ b/tests/prime_mmap_kms.c
> @@ -246,7 +246,7 @@ igt_main
> igt_skip_on((check_for_dma_buf_mmap(gpu.drm_fd) != 0));
> kmstest_set_vt_graphics_mode();
>
> - igt_require_pipe_crc();
> + igt_require_pipe_crc(gpu.drm_fd);
>
> igt_display_init(&gpu.display, gpu.drm_fd);
> }
> diff --git a/tools/intel_display_crc.c b/tools/intel_display_crc.c
> index ba9ec5baeb79..d1b28ea77371 100644
> --- a/tools/intel_display_crc.c
> +++ b/tools/intel_display_crc.c
> @@ -67,7 +67,7 @@ static void print_crcs(display_crc_t *ctx)
> char *crc_str;
> int i;
>
> - pipe_crc = igt_pipe_crc_new(ctx->pipe, INTEL_PIPE_CRC_SOURCE_AUTO);
> + pipe_crc = igt_pipe_crc_new(ctx->fd, ctx->pipe,
INTEL_PIPE_CRC_SOURCE_AUTO);
>
> for (i = 0; i < ctx->n_crcs; i++) {
> igt_pipe_crc_collect_crc(pipe_crc, &crc);
> diff --git a/tools/intel_display_poller.c b/tools/intel_display_poller.c
> index 63c930fb08a0..c501c79d6367 100644
> --- a/tools/intel_display_poller.c
> +++ b/tools/intel_display_poller.c
> @@ -965,6 +965,7 @@ int main(int argc, char *argv[])
> int pipe = 0, bit = 0, target_scanline = 0, target_fuzz = 1;
> bool test_pixelcount = false;
> uint32_t devid;
> + int drm_fd;
> uint32_t min[2*128] = {};
> uint32_t max[2*128] = {};
> uint32_t a, b;
> @@ -1186,7 +1187,10 @@ int main(int argc, char *argv[])
> break;
> }
>
> - intel_register_access_init(intel_get_pci_device(), 0);
> + /* Just to make sure we open the right debugfs files */
> + drm_fd = drm_open_driver_master(DRIVER_INTEL);
> +
> + intel_register_access_init(intel_get_pci_device(), 0, drm_fd);
>
> printf("%s?\n", test_name(test, pipe, bit, test_pixelcount));
>
> @@ -1263,6 +1267,8 @@ int main(int argc, char *argv[])
>
> intel_register_access_fini();
>
> + close(drm_fd);
> +
> if (quit)
> return 0;
>
> diff --git a/tools/intel_dp_compliance.c b/tools/intel_dp_compliance.c
> index 1b2c1d38490d..4b4d255daf16 100644
> --- a/tools/intel_dp_compliance.c
> +++ b/tools/intel_dp_compliance.c
> @@ -229,13 +229,13 @@ static void clear_test_active(void)
>
> static void setup_debugfs_files(void)
> {
> - test_type_fp = igt_debugfs_fopen(INTEL_DP_TEST_TYPE_FILE, "r");
> + test_type_fp = igt_debugfs_fopen(drm_fd, INTEL_DP_TEST_TYPE_FILE, "r");
> igt_require(test_type_fp);
>
> - test_data_fp = igt_debugfs_fopen(INTEL_DP_TEST_DATA_FILE, "r");
> + test_data_fp = igt_debugfs_fopen(drm_fd, INTEL_DP_TEST_DATA_FILE, "r");
> igt_require(test_data_fp);
>
> - test_active_fp = igt_debugfs_fopen(INTEL_DP_TEST_ACTIVE_FILE, "w+");
> + test_active_fp = igt_debugfs_fopen(drm_fd,
INTEL_DP_TEST_ACTIVE_FILE, "w+");
> igt_require(test_active_fp);
>
> /* Reset the active flag for safety */
> diff --git a/tools/intel_forcewaked.c b/tools/intel_forcewaked.c
> index 01ca02530d10..aa8e3f8b1cf4 100644
> --- a/tools/intel_forcewaked.c
> +++ b/tools/intel_forcewaked.c
> @@ -36,6 +36,7 @@
> #include <unistd.h>
> #include "intel_io.h"
> #include "intel_chipset.h"
> +#include "drmtest.h"
>
> bool daemonized;
>
> @@ -63,6 +64,7 @@ is_alive(void) {
>
> int main(int argc, char *argv[])
> {
> + int drm_fd;
> int ret;
>
> if (argc > 2 || (argc == 2 && !strncmp(argv[1], "-h", 2))) {
> @@ -79,7 +81,10 @@ int main(int argc, char *argv[])
> INFO_PRINT("started daemon");
> }
>
> - ret = intel_register_access_init(intel_get_pci_device(), 1);
> + /* Just to make sure we open the right debugfs files */
> + drm_fd = drm_open_driver_master(DRIVER_INTEL);
> +
> + ret = intel_register_access_init(intel_get_pci_device(), 1, drm_fd);
> if (ret) {
> INFO_PRINT("Couldn't init register access\n");
> exit(1);
> @@ -90,13 +95,14 @@ int main(int argc, char *argv[])
> if (!is_alive()) {
> INFO_PRINT("gpu reset? restarting daemon\n");
> intel_register_access_fini();
> - ret = intel_register_access_init(intel_get_pci_device(), 1);
> + ret = intel_register_access_init(intel_get_pci_device(), 1, drm_fd);
> if (ret)
> INFO_PRINT("Reg access init fail\n");
> }
> sleep(1);
> }
> intel_register_access_fini();
> + close(drm_fd);
> INFO_PRINT("Forcewake unlock\n");
>
> if (daemonized) {
> diff --git a/tools/intel_gpu_top.c b/tools/intel_gpu_top.c
> index 4f327c6daf6b..7848876476b6 100644
> --- a/tools/intel_gpu_top.c
> +++ b/tools/intel_gpu_top.c
> @@ -46,6 +46,7 @@
> #include "instdone.h"
> #include "intel_reg.h"
> #include "intel_chipset.h"
> +#include "drmtest.h"
>
> #define FORCEWAKE 0xA18C
> #define FORCEWAKE_ACK 0x130090
> @@ -410,6 +411,7 @@ usage(const char *appname)
> int main(int argc, char **argv)
> {
> uint32_t devid;
> + int drm_fd;
> struct pci_device *pci_dev;
> struct ring render_ring = {
> .name = "render",
> @@ -510,8 +512,11 @@ int main(int argc, char **argv)
> top_bits_sorted[i] = &top_bits[i];
> }
>
> + /* Just to make sure we open the right debugfs files */
> + drm_fd = drm_open_driver_master(DRIVER_INTEL);
> +
> /* Grab access to the registers */
> - intel_register_access_init(pci_dev, 0);
> + intel_register_access_init(pci_dev, 0, drm_fd);
>
> ring_init(&render_ring);
> if (IS_GEN4(devid) || IS_GEN5(devid))
> @@ -714,5 +719,6 @@ int main(int argc, char **argv)
> fclose(output);
>
> intel_register_access_fini();
> + close(drm_fd);
> return 0;
> }
> diff --git a/tools/intel_guc_logger.c b/tools/intel_guc_logger.c
> index c9ea60d054bb..3079878e1191 100644
> --- a/tools/intel_guc_logger.c
> +++ b/tools/intel_guc_logger.c
> @@ -47,7 +47,7 @@ int verbosity_level = 3; /* by default capture logs
at max verbosity */
> uint32_t produced, consumed;
> uint64_t total_bytes_written;
> int num_buffers = NUM_SUBBUFS;
> -int relay_fd, outfile_fd = -1;
> +int relay_fd, drm_fd, outfile_fd = -1;
> uint32_t test_duration, max_filesize;
> pthread_cond_t underflow_cond, overflow_cond;
> bool stop_logging, discard_oldlogs, capturing_stopped;
> @@ -59,7 +59,7 @@ static void guc_log_control(bool enable_logging)
> uint64_t val;
> int ret;
>
> - control_fd = igt_debugfs_open(CONTROL_FILE_NAME, O_WRONLY);
> + control_fd = igt_debugfs_open(drm_fd, CONTROL_FILE_NAME, O_WRONLY);
> igt_assert_f(control_fd >= 0, "couldn't open the guc log control
file\n");
>
> val = enable_logging ? ((verbosity_level << 4) | 0x1) : 0;
> @@ -228,7 +228,7 @@ static void init_flusher_thread(void)
>
> static void open_relay_file(void)
> {
> - relay_fd = igt_debugfs_open(RELAY_FILE_NAME, O_RDONLY);
> + relay_fd = igt_debugfs_open(drm_fd, RELAY_FILE_NAME, O_RDONLY);
> igt_assert_f(relay_fd >= 0, "couldn't open the guc log file\n");
>
> /* Purge the old/boot-time logs from the relay buffer.
> @@ -374,6 +374,9 @@ int main(int argc, char **argv)
>
> process_command_line(argc, argv);
>
> + /* Just to make sure we open the right debugfs files */
> + drm_fd = drm_open_driver_master(DRIVER_INTEL);
> +
> init_main_thread();
>
> /* Use a separate thread for flushing the logs to a file on disk.
> @@ -434,5 +437,6 @@ int main(int argc, char **argv)
> free(read_buffer);
> close(relay_fd);
> close(outfile_fd);
> + close(drm_fd);
> igt_exit();
> }
> diff --git a/tools/intel_infoframes.c b/tools/intel_infoframes.c
> index e03cb2c06a52..813430c985e7 100644
> --- a/tools/intel_infoframes.c
> +++ b/tools/intel_infoframes.c
> @@ -1081,6 +1081,7 @@ printf("Options:\n"
> int main(int argc, char *argv[])
> {
> int opt;
> + int drm_fd;
> int ret = 0;
> Transcoder transcoder = TRANSC_INVALID;
> DipType dip = DIP_INVALID;
> @@ -1107,8 +1108,11 @@ int main(int argc, char *argv[])
> printf("WARNING: This is just a debugging tool! Don't expect it to
work"
> " perfectly: the Kernel might undo our changes.\n");
>
> + /* Just to make sure we open the right debugfs files */
> + drm_fd = drm_open_driver_master(DRIVER_INTEL);
> +
> pci_dev = intel_get_pci_device();
> - intel_register_access_init(pci_dev, 0);
> + intel_register_access_init(pci_dev, 0, drm_fd);
> intel_check_pch();
>
> if (IS_GEN4(pci_dev->device_id))
> @@ -1257,5 +1261,6 @@ int main(int argc, char *argv[])
>
> out:
> intel_register_access_fini();
> + close(drm_fd);
> return ret;
> }
> diff --git a/tools/intel_l3_parity.c b/tools/intel_l3_parity.c
> index 8692bef870b7..dce7f3207051 100644
> --- a/tools/intel_l3_parity.c
> +++ b/tools/intel_l3_parity.c
> @@ -194,7 +194,7 @@ int main(int argc, char *argv[])
> if (intel_gen(devid) < 7 || IS_VALLEYVIEW(devid))
> exit(77);
>
> - assert(intel_register_access_init(intel_get_pci_device(), 0) == 0);
> + assert(intel_register_access_init(intel_get_pci_device(), 0,
device) == 0);
>
> dir = igt_sysfs_open(device, NULL);
>
> diff --git a/tools/intel_panel_fitter.c b/tools/intel_panel_fitter.c
> index 5519361e6c8c..48b2fd891497 100644
> --- a/tools/intel_panel_fitter.c
> +++ b/tools/intel_panel_fitter.c
> @@ -33,6 +33,7 @@
> #include "intel_io.h"
> #include "intel_chipset.h"
> #include "intel_reg.h"
> +#include "drmtest.h"
>
> int gen;
>
> @@ -265,7 +266,7 @@ static void print_usage(void)
>
> int main (int argc, char *argv[])
> {
> - int opt;
> + int opt, drm_fd;
> int ret = 0;
> char intel_pipe = '\0';
> int x = 0, y = 0;
> @@ -278,8 +279,11 @@ int main (int argc, char *argv[])
> "with overscan compensation properties: it is just a temporary "
> "solution that may or may not work. Use it at your own
risk.\n");
>
> + /* Just to make sure we open the right debugfs files */
> + drm_fd = drm_open_driver_master(DRIVER_INTEL);
> +
> pci_dev = intel_get_pci_device();
> - intel_register_access_init(pci_dev, 0);
> + intel_register_access_init(pci_dev, 0, drm_fd);
> devid = pci_dev->device_id;
>
> if (!HAS_PCH_SPLIT(devid)) {
> @@ -342,5 +346,6 @@ int main (int argc, char *argv[])
>
> out:
> intel_register_access_fini();
> + close(drm_fd);
> return ret;
> }
> diff --git a/tools/intel_perf_counters.c b/tools/intel_perf_counters.c
> index 04a6aba97808..50c4bce61ff7 100644
> --- a/tools/intel_perf_counters.c
> +++ b/tools/intel_perf_counters.c
> @@ -483,7 +483,7 @@ main(int argc, char **argv)
>
> if (oacontrol) {
> /* Forcewake */
> - intel_register_access_init(intel_get_pci_device(), 0);
> + intel_register_access_init(intel_get_pci_device(), 0, fd);
>
> /* Enable performance counters */
> intel_register_write(OACONTROL,
> diff --git a/tools/intel_reg.c b/tools/intel_reg.c
> index 01a3671e97dd..7b58d0b869f8 100644
> --- a/tools/intel_reg.c
> +++ b/tools/intel_reg.c
> @@ -32,6 +32,7 @@
> #include <sys/types.h>
> #include <unistd.h>
>
> +#include "igt.h"
> #include "intel_io.h"
> #include "intel_chipset.h"
>
> @@ -57,6 +58,7 @@ struct config {
> struct pci_device *pci_dev;
> char *mmiofile;
> uint32_t devid;
> + int drm_fd;
>
> /* read: number of registers to read */
> uint32_t count;
> @@ -409,7 +411,7 @@ static int intel_reg_read(struct config *config,
int argc, char *argv[])
> if (config->mmiofile)
> intel_mmio_use_dump_file(config->mmiofile);
> else
> - intel_register_access_init(config->pci_dev, 0);
> + intel_register_access_init(config->pci_dev, 0, config->drm_fd);
>
> for (i = 1; i < argc; i++) {
> struct reg reg;
> @@ -439,7 +441,7 @@ static int intel_reg_write(struct config *config,
int argc, char *argv[])
> return EXIT_FAILURE;
> }
>
> - intel_register_access_init(config->pci_dev, 0);
> + intel_register_access_init(config->pci_dev, 0, config->drm_fd);
>
> for (i = 1; i < argc; i += 2) {
> struct reg reg;
> @@ -477,7 +479,7 @@ static int intel_reg_dump(struct config *config,
int argc, char *argv[])
> if (config->mmiofile)
> intel_mmio_use_dump_file(config->mmiofile);
> else
> - intel_register_access_init(config->pci_dev, 0);
> + intel_register_access_init(config->pci_dev, 0, config->drm_fd);
>
> for (i = 0; i < config->regcount; i++) {
> reg = &config->regs[i];
> @@ -877,6 +879,9 @@ int main(int argc, char *argv[])
> config.devid = config.pci_dev->device_id;
> }
>
> + /* Just to make sure we open the right debugfs files */
> + config.drm_fd = drm_open_driver_master(DRIVER_INTEL);
> +
> if (read_reg_spec(&config) < 0) {
> return EXIT_FAILURE;
> }
> @@ -895,6 +900,7 @@ int main(int argc, char *argv[])
>
> ret = command->function(&config, argc, argv);
>
> + close(config.drm_fd);
> free(config.mmiofile);
>
> return ret;
> diff --git a/tools/intel_watermark.c b/tools/intel_watermark.c
> index e9a2b057b821..d98ef19b0abd 100644
> --- a/tools/intel_watermark.c
> +++ b/tools/intel_watermark.c
> @@ -30,11 +30,11 @@
> #include <string.h>
> #include "intel_io.h"
> #include "intel_chipset.h"
> +#include "drmtest.h"
>
> static uint32_t display_base;
> static uint32_t devid;
> -
> -#define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0]))
Nit: Maybe this should be a seperate commit.
> +static int drm_fd;
>
> static uint32_t read_reg(uint32_t addr)
> {
> @@ -143,7 +143,7 @@ static void ilk_wm_dump(void)
> int num_pipes = is_gen7_plus(devid) ? 3 : 2;
> struct ilk_wm wm = {};
>
> - intel_register_access_init(intel_get_pci_device(), 0);
> + intel_register_access_init(intel_get_pci_device(), 0, drm_fd);
>
> for (i = 0; i < num_pipes; i++) {
> dspcntr[i] = read_reg(0x70180 + i * 0x1000);
> @@ -291,7 +291,7 @@ static void vlv_wm_dump(void)
> uint32_t dsp_ss_pm, ddr_setup2;
> struct gmch_wm wms[MAX_PLANE] = {};
>
> - intel_register_access_init(intel_get_pci_device(), 0);
> + intel_register_access_init(intel_get_pci_device(), 0, drm_fd);
>
> dsparb = read_reg(0x70030);
> dsparb2 = read_reg(0x70060);
> @@ -507,7 +507,7 @@ static void g4x_wm_dump(void)
> uint32_t mi_arb_state;
> struct gmch_wm wms[MAX_PLANE] = {};
>
> - intel_register_access_init(intel_get_pci_device(), 0);
> + intel_register_access_init(intel_get_pci_device(), 0, drm_fd);
>
> dspacntr = read_reg(0x70180);
> dspbcntr = read_reg(0x71180);
> @@ -593,7 +593,7 @@ static void gen4_wm_dump(void)
> uint32_t mi_arb_state;
> struct gmch_wm wms[MAX_PLANE] = {};
>
> - intel_register_access_init(intel_get_pci_device(), 0);
> + intel_register_access_init(intel_get_pci_device(), 0, drm_fd);
>
> dsparb = read_reg(0x70030);
> fw1 = read_reg(0x70034);
> @@ -664,7 +664,7 @@ static void pnv_wm_dump(void)
> uint32_t cbr;
> struct gmch_wm wms[MAX_PLANE] = {};
>
> - intel_register_access_init(intel_get_pci_device(), 0);
> + intel_register_access_init(intel_get_pci_device(), 0, drm_fd);
>
> dsparb = read_reg(0x70030);
> fw1 = read_reg(0x70034);
> @@ -754,7 +754,7 @@ static void gen3_wm_dump(void)
> uint32_t mi_arb_state;
> struct gmch_wm wms[MAX_PLANE] = {};
>
> - intel_register_access_init(intel_get_pci_device(), 0);
> + intel_register_access_init(intel_get_pci_device(), 0, drm_fd);
>
> dsparb = read_reg(0x70030);
> instpm = read_reg(0x20c0);
> @@ -823,7 +823,7 @@ static void gen2_wm_dump(void)
> uint32_t mi_state;
> struct gmch_wm wms[MAX_PLANE] = {};
>
> - intel_register_access_init(intel_get_pci_device(), 0);
> + intel_register_access_init(intel_get_pci_device(), 0, drm_fd);
>
> dsparb = read_reg(0x70030);
> mem_mode = read_reg(0x20cc);
> @@ -900,6 +900,9 @@ int main(int argc, char *argv[])
> {
> devid = intel_get_pci_device()->device_id;
>
> + /* Just to make sure we open the right debugfs files */
> + drm_fd = drm_open_driver_master(DRIVER_INTEL);
> +
> if (IS_VALLEYVIEW(devid) || IS_CHERRYVIEW(devid)) {
> display_base = 0x180000;
> vlv_wm_dump();
> @@ -920,5 +923,7 @@ int main(int argc, char *argv[])
> return 1;
> }
>
> + close(drm_fd);
> +
> return 0;
> }
>
More information about the Intel-gfx
mailing list