[Intel-gfx] [PATCH i-g-t] tests/drm_import_export: Add tests for prime/flink sharing races

Thomas Wood thomas.wood at intel.com
Fri Jul 24 06:28:24 PDT 2015


On 24 July 2015 at 10:24, Michał Winiarski <michal.winiarski at intel.com> wrote:
> 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.

Could you add this description into the source file as a comment?
There also appears to be an extra white space change at the end of
your patch.

>
> Signed-off-by: Michał Winiarski <michal.winiarski at intel.com>
> ---
>  tests/drm_import_export.c | 103 ++++++++++++++++++++++++++++++++++++++++++++++
>  1 file changed, 103 insertions(+)
>
> diff --git a/tests/drm_import_export.c b/tests/drm_import_export.c
> index 57b13dd..db11c18 100644
> --- a/tests/drm_import_export.c
> +++ b/tests/drm_import_export.c
> @@ -131,6 +131,98 @@ 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;
> +};
> +
> +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;
> +}
> +
> +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 +245,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;
>
> @@ -180,4 +282,5 @@ igt_main {
>                 pthread_join(test_thread_id3, NULL);
>                 pthread_join(test_thread_id4, NULL);
>         }
> +
>  }
> --
> 2.4.3
>
> _______________________________________________
> Intel-gfx mailing list
> Intel-gfx at lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/intel-gfx


More information about the Intel-gfx mailing list