Revert "lib: Open debugfs files for the given DRM device"

This reverts commit 301ad44cdf1b868b1ab89096721da91fa8541fdc.

When a render-only device is opened and gem_quiescent_gpu is called, we
need to use the debugfs dir for the master device instead.

Signed-off-by: Tomeu Vizoso <tomeu.vizoso@collabora.com>

12 files changed, 121 insertions, 169 deletions

diff --git a/lib/drmtest.c b/lib/drmtest.c
index 35f71c0d..065ab119 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(fd, DROP_RETIRE | DROP_FREED);
+	igt_drop_caches_set(DROP_RETIRE | DROP_FREED);
 }
 
 /**
diff --git a/lib/igt_aux.c b/lib/igt_aux.c
index 1222806c..7ee279a3 100644
--- a/lib/igt_aux.c
+++ b/lib/igt_aux.c
@@ -350,10 +350,10 @@ void igt_stop_signal_helper(void)
 }
 
 static struct igt_helper_process shrink_helper;
-static void __attribute__((noreturn)) shrink_helper_process(int fd, pid_t pid)
+static void __attribute__((noreturn)) shrink_helper_process(pid_t pid)
 {
 	while (1) {
-		igt_drop_caches_set(fd, DROP_SHRINK_ALL);
+		igt_drop_caches_set(DROP_SHRINK_ALL);
 		usleep(1000 * 1000 / 50);
 		if (kill(pid, 0)) /* Parent has died, so must we. */
 			exit(0);
@@ -370,12 +370,12 @@ static void __attribute__((noreturn)) shrink_helper_process(int fd, pid_t pid)
  *
  * This should only be used from an igt_fixture.
  */
-void igt_fork_shrink_helper(int drm_fd)
+void igt_fork_shrink_helper(void)
 {
 	assert(!igt_only_list_subtests());
-	igt_require(igt_drop_caches_has(drm_fd, DROP_SHRINK_ALL));
+	igt_require(igt_drop_caches_has(DROP_SHRINK_ALL));
 	igt_fork_helper(&shrink_helper)
-		shrink_helper_process(drm_fd, getppid());
+		shrink_helper_process(getppid());
 }
 
 /**
diff --git a/lib/igt_aux.h b/lib/igt_aux.h
index e62858e6..13f6f156 100644
--- a/lib/igt_aux.h
+++ b/lib/igt_aux.h
@@ -51,7 +51,7 @@ extern int num_trash_bos;
 void igt_fork_signal_helper(void);
 void igt_stop_signal_helper(void);
 
-void igt_fork_shrink_helper(int fd);
+void igt_fork_shrink_helper(void);
 void igt_stop_shrink_helper(void);
 
 void igt_fork_hang_detector(int fd);
@@ -198,7 +198,7 @@ void igt_debug_manual_check(const char *var, const char *expected);
 
 /* These are separate to allow easier testing when porting, see the comment at
  * the bottom of intel_os.c. */
-void intel_purge_vm_caches(int fd);
+void intel_purge_vm_caches(void);
 uint64_t intel_get_avail_ram_mb(void);
 uint64_t intel_get_total_ram_mb(void);
 uint64_t intel_get_total_swap_mb(void);
diff --git a/lib/igt_debugfs.c b/lib/igt_debugfs.c
index 629bbddf..527e6858 100644
--- a/lib/igt_debugfs.c
+++ b/lib/igt_debugfs.c
@@ -131,34 +131,39 @@ const char *igt_debugfs_mount(void)
 	return "/sys/kernel/debug";
 }
 
-static char *
-igt_get_debugfs_path(int fd)
+static bool __igt_debugfs_init(igt_debugfs_t *debugfs)
 {
 	struct stat st;
-	const char *debugfs_root;
-	char *debugfs_dri_path;
-	int len;
-
-	if (fstat(fd, &st)) {
-		igt_debug("Couldn't stat FD for DRM device: %s\n", strerror(errno));
-		return NULL;
+	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;
+		}
 	}
 
-	if (!S_ISCHR(st.st_mode)) {
-		igt_debug("FD for DRM device not a char device!\n");
-		return NULL;
-	}
+	debugfs->dri_path[0] = '\0';
+	return false;
+}
 
-	debugfs_root = igt_debugfs_mount();
-	debugfs_dri_path = calloc(1, strlen(debugfs_root) + 100);
-	len = sprintf(debugfs_dri_path, "%s/dri/%d", debugfs_root, minor(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;
-	}
+static igt_debugfs_t *__igt_debugfs_singleton(void)
+{
+	static igt_debugfs_t singleton;
+	static bool init_done = false;
 
-	return NULL;
+	if (init_done)
+		return &singleton;
+
+	if (__igt_debugfs_init(&singleton)) {
+		init_done = true;
+		return &singleton;
+	} else {
+		return NULL;
+	}
 }
 
 /**
@@ -172,19 +177,15 @@ igt_get_debugfs_path(int fd)
  * Returns:
  * The Unix file descriptor for the debugfs file or -1 if that didn't work out.
  */
-int igt_debugfs_open(int fd, const char *filename, int mode)
+int igt_debugfs_open(const char *filename, int mode)
 {
 	char buf[1024];
-	char *debugfs_dri_path;
+	igt_debugfs_t *debugfs = __igt_debugfs_singleton();
 
-	debugfs_dri_path = igt_get_debugfs_path(fd);
-	if (!debugfs_dri_path)
+	if (!debugfs)
 		return -1;
 
-	sprintf(buf, "%s/%s", debugfs_dri_path, filename);
-
-	free(debugfs_dri_path);
-
+	sprintf(buf, "%s/%s", debugfs->dri_path, filename);
 	return open(buf, mode);
 }
 
@@ -199,21 +200,17 @@ int igt_debugfs_open(int fd, 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(int fd,
-			const char *filename,
+FILE *igt_debugfs_fopen(const char *filename,
 			const char *mode)
 {
 	char buf[1024];
-	char *debugfs_dri_path;
-
-	debugfs_dri_path = igt_get_debugfs_path(fd);
-	if (!debugfs_dri_path)
-		return NULL;
 
-	sprintf(buf, "%s/%s", debugfs_dri_path, filename);
+	igt_debugfs_t *debugfs = __igt_debugfs_singleton();
 
-	free(debugfs_dri_path);
+	if (!debugfs)
+		return NULL;
 
+	sprintf(buf, "%s/%s", debugfs->dri_path, filename);
 	return fopen(buf, mode);
 }
 
@@ -227,12 +224,12 @@ FILE *igt_debugfs_fopen(int fd,
  * 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(int fd, const char *filename, char *buf, int buf_size)
+void __igt_debugfs_read(const char *filename, char *buf, int buf_size)
 {
 	FILE *file;
 	size_t n_read;
 
-	file = igt_debugfs_fopen(fd, filename, "r");
+	file = igt_debugfs_fopen(filename, "r");
 	igt_assert(file);
 
 	n_read = fread(buf, 1, buf_size - 1, file);
@@ -253,14 +250,14 @@ void __igt_debugfs_read(int fd, const char *filename, char *buf, int buf_size)
  *
  * Returns: True if the @substring is found to occur in @filename
  */
-bool igt_debugfs_search(int fd, const char *filename, const char *substring)
+bool igt_debugfs_search(const char *filename, const char *substring)
 {
 	FILE *file;
 	size_t n = 0;
 	char *line = NULL;
 	bool matched = false;
 
-	file = igt_debugfs_fopen(fd, filename, "r");
+	file = igt_debugfs_fopen(filename, "r");
 	igt_assert(file);
 
 	while (getline(&line, &n, file) >= 0) {
@@ -325,7 +322,6 @@ 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;
@@ -374,7 +370,7 @@ static bool igt_pipe_crc_do_start(igt_pipe_crc_t *pipe_crc)
 		sprintf(buf, "crtc-%d/crc/data", pipe_crc->pipe);
 		err = 0;
 
-		pipe_crc->crc_fd = igt_debugfs_open(pipe_crc->fd, buf, pipe_crc->flags);
+		pipe_crc->crc_fd = igt_debugfs_open(buf, pipe_crc->flags);
 		if (pipe_crc->crc_fd < 0)
 			err = -errno;
 
@@ -396,27 +392,23 @@ 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(int drm_fd)
+static void igt_pipe_crc_reset(void)
 {
+	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)
@@ -429,12 +421,11 @@ static void igt_pipe_crc_reset(int drm_fd)
 		}
 		closedir(dir);
 	}
-	free(debugfs_dri_path);
 
 	if (done)
 		return;
 
-	fd = igt_debugfs_open(drm_fd, "i915_display_crc_ctl", O_WRONLY);
+	fd = igt_debugfs_open("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);
@@ -446,32 +437,7 @@ static void igt_pipe_crc_reset(int drm_fd)
 
 static void pipe_crc_exit_handler(int sig)
 {
-	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);
+	igt_pipe_crc_reset();
 }
 
 /**
@@ -481,16 +447,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(int fd)
+void igt_require_pipe_crc(void)
 {
 	const char *cmd = "pipe A none";
 	FILE *ctl;
 	size_t written;
 	int ret;
 
-	ctl = igt_debugfs_fopen(fd, "crtc-0/crc/control", "r+");
+	ctl = igt_debugfs_fopen("crtc-0/crc/control", "r+");
 	if (!ctl) {
-		ctl = igt_debugfs_fopen(fd, "i915_display_crc_ctl", "r+");
+		ctl = igt_debugfs_fopen("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);
@@ -502,16 +468,6 @@ void igt_require_pipe_crc(int fd)
 	fclose(ctl);
 }
 
-static void igt_hpd_storm_exit_handler(int sig)
-{
-	int fd = drm_open_driver_master(DRIVER_INTEL);
-
-	/* Here we assume that only one i915 device will be ever present */
-	igt_hpd_storm_reset(fd);
-
-	close(fd);
-}
-
 /**
  * igt_hpd_storm_set_threshold:
  * @threshold: How many hotplugs per second required to trigger an HPD storm,
@@ -526,9 +482,9 @@ static void igt_hpd_storm_exit_handler(int sig)
  *
  * See: https://01.org/linuxgraphics/gfx-docs/drm/gpu/i915.html#hotplug
  */
-void igt_hpd_storm_set_threshold(int drm_fd, unsigned int threshold)
+void igt_hpd_storm_set_threshold(unsigned int threshold)
 {
-	int fd = igt_debugfs_open(drm_fd, "i915_hpd_storm_ctl", O_WRONLY);
+	int fd = igt_debugfs_open("i915_hpd_storm_ctl", O_WRONLY);
 	char buf[16];
 
 	if (fd < 0)
@@ -539,7 +495,7 @@ void igt_hpd_storm_set_threshold(int drm_fd, unsigned int threshold)
 	igt_assert_eq(write(fd, buf, strlen(buf)), strlen(buf));
 
 	close(fd);
-	igt_install_exit_handler(igt_hpd_storm_exit_handler);
+	igt_install_exit_handler((igt_exit_handler_t)igt_hpd_storm_reset);
 }
 
 /**
@@ -555,9 +511,9 @@ void igt_hpd_storm_set_threshold(int drm_fd, unsigned int threshold)
  *
  * See: https://01.org/linuxgraphics/gfx-docs/drm/gpu/i915.html#hotplug
  */
-void igt_hpd_storm_reset(int drm_fd)
+void igt_hpd_storm_reset(void)
 {
-	int fd = igt_debugfs_open(drm_fd, "i915_hpd_storm_ctl", O_WRONLY);
+	int fd = igt_debugfs_open("i915_hpd_storm_ctl", O_WRONLY);
 	const char *buf = "reset";
 
 	if (fd < 0)
@@ -582,9 +538,9 @@ void igt_hpd_storm_reset(int drm_fd)
  *
  * Returns: Whether or not an HPD storm has been detected.
  */
-bool igt_hpd_storm_detected(int drm_fd)
+bool igt_hpd_storm_detected(void)
 {
-	int fd = igt_debugfs_open(drm_fd, "i915_hpd_storm_ctl", O_RDONLY);
+	int fd = igt_debugfs_open("i915_hpd_storm_ctl", O_RDONLY);
 	char *start_loc;
 	char buf[32] = {0}, detected_str[4];
 	bool ret;
@@ -615,16 +571,16 @@ bool igt_hpd_storm_detected(int drm_fd)
  *
  * See: https://01.org/linuxgraphics/gfx-docs/drm/gpu/i915.html#hotplug
  */
-void igt_require_hpd_storm_ctl(int drm_fd)
+void igt_require_hpd_storm_ctl(void)
 {
-	int fd = igt_debugfs_open(drm_fd, "i915_hpd_storm_ctl", O_RDONLY);
+	int fd = igt_debugfs_open("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(int fd, enum pipe pipe, enum intel_pipe_crc_source source, int flags)
+pipe_crc_new(enum pipe pipe, enum intel_pipe_crc_source source, int flags)
 {
 	igt_pipe_crc_t *pipe_crc;
 	char buf[128];
@@ -634,9 +590,9 @@ pipe_crc_new(int fd, enum pipe pipe, enum intel_pipe_crc_source source, int flag
 	pipe_crc = calloc(1, sizeof(struct _igt_pipe_crc));
 
 	sprintf(buf, "crtc-%d/crc/control", pipe);
-	pipe_crc->ctl_fd = igt_debugfs_open(fd, buf, O_WRONLY);
+	pipe_crc->ctl_fd = igt_debugfs_open(buf, O_WRONLY);
 	if (pipe_crc->ctl_fd == -1) {
-		pipe_crc->ctl_fd = igt_debugfs_open(fd, "i915_display_crc_ctl",
+		pipe_crc->ctl_fd = igt_debugfs_open("i915_display_crc_ctl",
 						    O_WRONLY);
 		igt_assert(pipe_crc->ctl_fd != -1);
 		pipe_crc->is_legacy = true;
@@ -644,7 +600,7 @@ pipe_crc_new(int fd, enum pipe pipe, enum intel_pipe_crc_source source, int flag
 
 	if (pipe_crc->is_legacy) {
 		sprintf(buf, "i915_pipe_%s_crc", kmstest_pipe_name(pipe));
-		pipe_crc->crc_fd = igt_debugfs_open(fd, buf, flags);
+		pipe_crc->crc_fd = igt_debugfs_open(buf, flags);
 		igt_assert(pipe_crc->crc_fd != -1);
 		igt_debug("Using legacy frame CRC ABI\n");
 	} else {
@@ -652,7 +608,6 @@ pipe_crc_new(int fd, enum pipe pipe, enum intel_pipe_crc_source source, int flag
 		igt_debug("Using generic frame CRC ABI\n");
 	}
 
-	pipe_crc->fd = fd;
 	pipe_crc->pipe = pipe;
 	pipe_crc->source = source;
 	pipe_crc->flags = flags;
@@ -673,9 +628,9 @@ pipe_crc_new(int fd, enum pipe pipe, enum intel_pipe_crc_source source, int flag
  * least INTEL_PIPE_CRC_SOURCE_AUTO everywhere.
  */
 igt_pipe_crc_t *
-igt_pipe_crc_new(int fd, enum pipe pipe, enum intel_pipe_crc_source source)
+igt_pipe_crc_new(enum pipe pipe, enum intel_pipe_crc_source source)
 {
-	return pipe_crc_new(fd, pipe, source, O_RDONLY);
+	return pipe_crc_new(pipe, source, O_RDONLY);
 }
 
 /**
@@ -691,9 +646,9 @@ igt_pipe_crc_new(int fd, 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(int fd, enum pipe pipe, enum intel_pipe_crc_source source)
+igt_pipe_crc_new_nonblock(enum pipe pipe, enum intel_pipe_crc_source source)
 {
-	return pipe_crc_new(fd, pipe, source, O_RDONLY | O_NONBLOCK);
+	return pipe_crc_new(pipe, source, O_RDONLY | O_NONBLOCK);
 }
 
 /**
@@ -929,13 +884,13 @@ void igt_pipe_crc_collect_crc(igt_pipe_crc_t *pipe_crc, igt_crc_t *out_crc)
  * This queries the debugfs to see if it supports the full set of desired
  * operations.
  */
-bool igt_drop_caches_has(int drm_fd, uint64_t val)
+bool igt_drop_caches_has(uint64_t val)
 {
 	FILE *file;
 	uint64_t mask;
 
 	mask = 0;
-	file = igt_debugfs_fopen(drm_fd, "i915_gem_drop_caches", "r");
+	file = igt_debugfs_fopen("i915_gem_drop_caches", "r");
 	if (file) {
 		igt_ignore_warn(fscanf(file, "0x%" PRIx64, &mask));
 		fclose(file);
@@ -951,7 +906,7 @@ bool igt_drop_caches_has(int drm_fd, uint64_t val)
  * 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(int drm_fd, uint64_t val)
+void igt_drop_caches_set(uint64_t val)
 {
 	int fd;
 	char data[19];
@@ -959,7 +914,7 @@ void igt_drop_caches_set(int drm_fd, uint64_t val)
 
 	sprintf(data, "0x%" PRIx64, val);
 
-	fd = igt_debugfs_open(drm_fd, "i915_gem_drop_caches", O_WRONLY);
+	fd = igt_debugfs_open("i915_gem_drop_caches", O_WRONLY);
 
 	igt_assert(fd >= 0);
 	do {
@@ -1025,14 +980,14 @@ void igt_enable_prefault(void)
 	igt_prefault_control(true);
 }
 
-static int get_object_count(int fd)
+static int get_object_count(void)
 {
 	FILE *file;
 	int ret, scanned;
 
-	igt_drop_caches_set(fd, DROP_RETIRE | DROP_ACTIVE | DROP_FREED);
+	igt_drop_caches_set(DROP_RETIRE | DROP_ACTIVE | DROP_FREED);
 
-	file = igt_debugfs_fopen(fd, "i915_gem_objects", "r");
+	file = igt_debugfs_fopen("i915_gem_objects", "r");
 
 	scanned = fscanf(file, "%i objects", &ret);
 	igt_assert_eq(scanned, 1);
@@ -1052,7 +1007,7 @@ int igt_get_stable_obj_count(int driver)
 {
 	int obj_count;
 	gem_quiescent_gpu(driver);
-	obj_count = get_object_count(driver);
+	obj_count = get_object_count();
 	/* 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
@@ -1066,7 +1021,7 @@ int igt_get_stable_obj_count(int driver)
 		while (loop_count < 4) {
 			usleep(200000);
 			gem_quiescent_gpu(driver);
-			obj_count = get_object_count(driver);
+			obj_count = get_object_count();
 			if (obj_count == prev_obj_count) {
 				loop_count++;
 			} else {
diff --git a/lib/igt_debugfs.h b/lib/igt_debugfs.h
index ff396564..aa59f8a8 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(int fd, const char *filename, int mode);
-FILE *igt_debugfs_fopen(int fd, const char *filename,
+int igt_debugfs_open(const char *filename, int mode);
+FILE *igt_debugfs_fopen(const char *filename,
 			const char *mode);
-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);
+void __igt_debugfs_read(const char *filename, char *buf, int buf_size);
+bool igt_debugfs_search(const char *filename, const char *substring);
 
 /**
  * igt_debugfs_read:
@@ -47,8 +47,8 @@ bool igt_debugfs_search(int fd, const char *filename, const char *substring);
  * This is just a convenience wrapper for __igt_debugfs_read. See its
  * documentation.
  */
-#define igt_debugfs_read(fd, filename, buf) \
-		__igt_debugfs_read(fd, (filename), (buf), sizeof(buf))
+#define igt_debugfs_read(filename, buf) \
+		__igt_debugfs_read((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(int fd);
+void igt_require_pipe_crc(void);
 igt_pipe_crc_t *
-igt_pipe_crc_new(int fd, enum pipe pipe, enum intel_pipe_crc_source source);
+igt_pipe_crc_new(enum pipe pipe, enum intel_pipe_crc_source source);
 igt_pipe_crc_t *
-igt_pipe_crc_new_nonblock(int fd, enum pipe pipe, enum intel_pipe_crc_source source);
+igt_pipe_crc_new_nonblock(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(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);
+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);
 
 /*
  * Drop caches
@@ -188,8 +188,8 @@ void igt_require_hpd_storm_ctl(int fd);
 		  DROP_ACTIVE | \
 		  DROP_FREED)
 
-bool igt_drop_caches_has(int fd, uint64_t val);
-void igt_drop_caches_set(int fd, uint64_t val);
+bool igt_drop_caches_has(uint64_t val);
+void igt_drop_caches_set(uint64_t val);
 
 /*
  * Prefault control
diff --git a/lib/igt_gt.c b/lib/igt_gt.c
index 69218681..b8e08e9a 100644
--- a/lib/igt_gt.c
+++ b/lib/igt_gt.c
@@ -360,14 +360,14 @@ 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(int drm_fd)
+void igt_force_gpu_reset(void)
 {
 	FILE *file;
 	int fd, ret, wedged;
 
 	igt_debug("Triggering GPU reset\n");
 
-	fd = igt_debugfs_open(drm_fd, "i915_wedged", O_RDWR);
+	fd = igt_debugfs_open("i915_wedged", O_RDWR);
 	igt_require(fd >= 0);
 
 	ret = write(fd, "-1\n", 3);
@@ -375,7 +375,7 @@ void igt_force_gpu_reset(int drm_fd)
 
 	igt_assert_eq(ret, 3);
 
-	file = igt_debugfs_fopen(drm_fd, "i915_wedged", "r");
+	file = igt_debugfs_fopen("i915_wedged", "r");
 	igt_assert(file);
 
 	wedged = 1;
@@ -451,11 +451,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(int fd)
+int igt_open_forcewake_handle(void)
 {
 	if (getenv("IGT_NO_FORCEWAKE"))
 		return -1;
-	return igt_debugfs_open(fd, "i915_forcewake_user", O_WRONLY);
+	return igt_debugfs_open("i915_forcewake_user", O_WRONLY);
 }
 
 #if defined(__x86_64__) || defined(__i386__)
@@ -543,13 +543,13 @@ unsigned intel_detect_and_clear_missed_interrupts(int fd)
 
 	gem_quiescent_gpu(fd);
 
-	file = igt_debugfs_fopen(fd, "i915_ring_missed_irq", "r");
+	file = igt_debugfs_fopen("i915_ring_missed_irq", "r");
 	if (file) {
 		igt_assert(fscanf(file, "%x", &missed) == 1);
 		fclose(file);
 	}
 	if (missed) {
-		file = igt_debugfs_fopen(fd, "i915_ring_missed_irq", "w");
+		file = igt_debugfs_fopen("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 1ed833d2..e44b6db1 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(int fd);
+void igt_force_gpu_reset(void);
 
 void igt_fork_hang_helper(void);
 void igt_stop_hang_helper(void);
 
-int igt_open_forcewake_handle(int fd);
+int igt_open_forcewake_handle(void);
 
 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 d9f96725..a986145e 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(drm_fd, path, O_WRONLY | O_TRUNC);
+	debugfs_fd = igt_debugfs_open(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(int fd, enum pipe pipe, struct kmstest_crtc *crtc)
+void kmstest_get_crtc(enum pipe pipe, struct kmstest_crtc *crtc)
 {
 	char tmp[256];
 	FILE *fid;
@@ -1333,7 +1333,7 @@ void kmstest_get_crtc(int fd, enum pipe pipe, struct kmstest_crtc *crtc)
 	int line;
 	long int n;
 
-	fid = igt_debugfs_fopen(fd, "i915_display_info", mode);
+	fid = igt_debugfs_fopen("i915_display_info", mode);
 
 	igt_skip_on(fid == NULL);
 
@@ -1370,13 +1370,13 @@ void kmstest_get_crtc(int fd, enum pipe pipe, struct kmstest_crtc *crtc)
 	igt_skip_on(ncrtc == 0);
 }
 
-void igt_assert_plane_visible(int fd, enum pipe pipe, bool visibility)
+void igt_assert_plane_visible(enum pipe pipe, bool visibility)
 {
 	struct kmstest_crtc crtc;
 	int i;
 	bool visible;
 
-	kmstest_get_crtc(fd, pipe, &crtc);
+	kmstest_get_crtc(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 595832d0..862525d1 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(int fd, enum pipe pipe, struct kmstest_crtc *crtc);
-void igt_assert_plane_visible(int fd, enum pipe pipe, bool visibility);
+void kmstest_get_crtc(enum pipe pipe, struct kmstest_crtc *crtc);
+void igt_assert_plane_visible(enum pipe pipe, bool visibility);
 
 /*
  * A small modeset API
diff --git a/lib/intel_io.h b/lib/intel_io.h
index 6014c485..e2d6b470 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 fd);
+int intel_register_access_init(struct pci_device *pci_dev, int safe);
 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 07b9ed14..4981daf9 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, int fd)
+intel_register_access_init(struct pci_device *pci_dev, int safe)
 {
 	int ret;
 
@@ -187,7 +187,7 @@ intel_register_access_init(struct pci_device *pci_dev, int safe, int fd)
 	/* 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(fd);
+	ret = igt_open_forcewake_handle();
 	if (ret == -1)
 		mmio_data.key = FAKEKEY;
 	else
diff --git a/lib/intel_os.c b/lib/intel_os.c
index e5dea6e5..924ac7e7 100644
--- a/lib/intel_os.c
+++ b/lib/intel_os.c
@@ -97,11 +97,8 @@ intel_get_avail_ram_mb(void)
 
 #ifdef HAVE_STRUCT_SYSINFO_TOTALRAM /* Linux */
 	struct sysinfo sysinf;
-	int fd;
 
-	fd = drm_open_driver(DRIVER_INTEL);
-	intel_purge_vm_caches(fd);
-	close(fd);
+	intel_purge_vm_caches();
 
 	igt_assert(sysinfo(&sysinf) == 0);
 	retval = sysinf.freeram;
@@ -295,11 +292,11 @@ void intel_require_memory(uint64_t count, uint64_t size, unsigned mode)
 	igt_skip_on_simulation();
 }
 
-void intel_purge_vm_caches(int drm_fd)
+void intel_purge_vm_caches(void)
 {
 	int fd;
 
-	igt_drop_caches_set(drm_fd, DROP_SHRINK_ALL);
+	igt_drop_caches_set(DROP_SHRINK_ALL);
 
 	fd = open("/proc/sys/vm/drop_caches", O_WRONLY);
 	if (fd >= 0) {