It is possible to race between unreference of the underlying BO and
importing it from prime_fd/name. Verify that the behaviour of libdrm
is consistent for prime/flink.
v2: more comments in source file, dropped extra whitespace
Signed-off-by: Michał Winiarski <michal.winiar...@intel.com>
Cc: Thomas Wood <thomas.w...@intel.com>
---
tests/drm_import_export.c | 112 ++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 112 insertions(+)
diff --git a/tests/drm_import_export.c b/tests/drm_import_export.c
index 57b13dd..e24e0df 100644
--- a/tests/drm_import_export.c
+++ b/tests/drm_import_export.c
@@ -131,6 +131,108 @@ static void * test_thread(void * par)
return NULL;
}
+#define IMPORT_RACE_LOOPS 100000
+
+struct import_race_thread_data {
+ int prime_fd;
+ uint32_t flink_name;
+ unsigned int stop;
+ pthread_mutex_t mutex;
+};
+
+/*
+ * Attempt to import the bo. It is possible that GEM_CLOSE was already called
+ * in different thread and from i915 point of view the handle is no longer
+ * valid (thus create_from_prime/name should fail).
+ */
+static void *import_close_thread(void *data)
+{
+ struct import_race_thread_data *t = (struct import_race_thread_data
*)data;
+ drm_intel_bo *bo;
+ pthread_mutex_lock(&t->mutex);
+ while (!t->stop) {
+ pthread_mutex_unlock(&t->mutex);
+ bo = NULL;
+ if (use_flink)
+ bo = drm_intel_bo_gem_create_from_name(bufmgr,
"buf-shared", t->flink_name);
+ else {
+ pthread_mutex_lock(&t->mutex);
+ if (t->prime_fd != -1) {
+ bo = drm_intel_bo_gem_create_from_prime(bufmgr,
t->prime_fd, 4096);
+ pthread_mutex_unlock(&t->mutex);
+ }
+ else
+ /* We take the lock right after entering the
loop */
+ continue;
+ }
+ if (bo == NULL) {
+ /*
+ * If the bo is NULL it means that we've unreferenced
in other
+ * thread - therefore we should expect ENOENT
+ */
+ igt_assert_eq(errno, ENOENT);
+ continue;
+ }
+
+ drm_intel_bo_unreference(bo);
+
+ pthread_mutex_lock(&t->mutex);
+ }
+ pthread_mutex_unlock(&t->mutex);
+
+ return NULL;
+}
+
+/*
+ * It is possible to race between unreference of the underlying BO and
importing
+ * it from prime_fd/name. Verify that the behaviour of libdrm is consistent for
+ * prime/flink.
+ */
+static void test_import_close_race(void)
+{
+ pthread_t t;
+ unsigned int loops = IMPORT_RACE_LOOPS;
+ drm_intel_bo *bo;
+ struct import_race_thread_data t_data;
+
+ memset(&t_data, 0, sizeof(t_data));
+ pthread_mutex_init(&t_data.mutex, NULL);
+ t_data.prime_fd = -1;
+
+ igt_assert_eq(pthread_create(&t, NULL, import_close_thread , &t_data),
0);
+
+ while (loops--) {
+ bo = drm_intel_bo_alloc(bufmgr, "buf-shared", 4096, 4096);
+ igt_assert(bo != NULL);
+ /*
+ * We setup the test in such way, that create_from_* can race
between
+ * unreference. If we're using prime, prime_fd is always a
valid fd.
+ */
+ if (use_flink)
+ igt_assert_eq(drm_intel_bo_flink(bo,
&(t_data.flink_name)), 0);
+ else {
+ pthread_mutex_lock(&t_data.mutex);
+ igt_assert_eq(drm_intel_bo_gem_export_to_prime(bo,
&(t_data.prime_fd)), 0);
+ igt_assert(t_data.prime_fd != -1);
+ pthread_mutex_unlock(&t_data.mutex);
+ }
+
+ drm_intel_bo_unreference(bo);
+
+ pthread_mutex_lock(&t_data.mutex);
+ close(t_data.prime_fd);
+ t_data.prime_fd = -1;
+ pthread_mutex_unlock(&t_data.mutex);
+ }
+
+ pthread_mutex_lock(&t_data.mutex);
+ t_data.stop = 1;
+ pthread_mutex_unlock(&t_data.mutex);
+
+ pthread_join(t, NULL);
+ pthread_mutex_destroy(&t_data.mutex);
+}
+
pthread_t test_thread_id1;
pthread_t test_thread_id2;
pthread_t test_thread_id3;
@@ -153,6 +255,16 @@ igt_main {
drm_intel_bufmgr_gem_enable_reuse(bufmgr);
}
+ igt_subtest("import-close-race-flink") {
+ use_flink = true;
+ test_import_close_race();
+ }
+
+ igt_subtest("import-close-race-prime") {
+ use_flink = false;
+ test_import_close_race();
+ }
+
igt_subtest("flink") {
use_flink = true;
--
2.4.3
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
