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>

1 files changed, 76 insertions, 121 deletions

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 {