flywithu/ntel-gpu-tools
1
0
Fork 0
mirror of https://github.com/tiagovignatti/intel-gpu-tools.git synced 2025-06-20 14:26:17 +00:00
Code Issues Releases Wiki Activity

tests/drm_import_export: Add tests for prime/flink sharing races

Browse Source 
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.winiarski@intel.com>
Cc: Thomas Wood <thomas.wood@intel.com>
Signed-off-by: Thomas Wood <thomas.wood@intel.com>
This commit is contained in:
Michał Winiarski 2015-07-24 16:43:33 +02:00 committed by Thomas Wood
parent e14507ce98
commit d49a868378
1 changed files with 112 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

112
tests/drm_import_export.c
View File

@ -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;