tests/gem_userptr_blits: Race between object creation and multi-threaded mm ops
PATCH 1/1 tests/gem_userptr_blits: Race between object creation and multi-threaded mm ops
From: Tvrtko Ursulin <[email protected]>
Userptr v23 was not thread safe against memory map operations and object creation from separate threads. MMU notifier callback would get triggered on a partially constructed object causing a NULL pointer dereference.
This test excercises that path a bit. In my testing it would trigger it every time and easily, but unfortunately a test pass here does not guarantee the absence of the race.
--- tests/Makefile.am | 2 ++ tests/gem_userptr_blits.c | 54 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 56 insertions(+)
tests/Makefile.am +2 -0
@@ -65,6 +65,8 @@ prime_self_import_CFLAGS = $(AM_CFLAGS) $(THREAD_CFLAGS) prime_self_import_LDADD = $(LDADD) -lpthread gen7_forcewake_mt_CFLAGS = $(AM_CFLAGS) $(THREAD_CFLAGS) gen7_forcewake_mt_LDADD = $(LDADD) -lpthread +gem_userptr_blits_CFLAGS = $(AM_CFLAGS) $(THREAD_CFLAGS) +gem_userptr_blits_LDADD = $(LDADD) -lpthread gem_wait_render_timeout_LDADD = $(LDADD) -lrt kms_flip_LDADD = $(LDADD) -lrt -lpthread
tests/gem_userptr_blits.c +54 -0
72 lines not on this page · raw message
Signature · 1 line
1.9.3
Quoted 79 lines · Tvrtko Ursulin
From: Tvrtko Ursulin <[email protected]>
Userptr v23 was not thread safe against memory map operations and object creation from separate threads. MMU notifier callback would get triggered on a partially constructed object causing a NULL pointer dereference.
This test excercises that path a bit. In my testing it would trigger it every time and easily, but unfortunately a test pass here does not guarantee the absence of the race.
Signed-off-by Tvrtko Ursulin <[email protected]>Cc Chris Wilson <[email protected]>--- tests/Makefile.am | 2 ++ tests/gem_userptr_blits.c | 54 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 56 insertions(+)tests/Makefile.am +2
-0@@ -65,6 +65,8 @@ prime_self_import_CFLAGS = $(AM_CFLAGS) $(THREAD_CFLAGS) prime_self_import_LDADD = $(LDADD) -lpthread gen7_forcewake_mt_CFLAGS = $(AM_CFLAGS) $(THREAD_CFLAGS) gen7_forcewake_mt_LDADD = $(LDADD) -lpthread +gem_userptr_blits_CFLAGS = $(AM_CFLAGS) $(THREAD_CFLAGS) +gem_userptr_blits_LDADD = $(LDADD) -lpthread gem_wait_render_timeout_LDADD = $(LDADD) -lrt kms_flip_LDADD = $(LDADD) -lrt -lpthreadtests/gem_userptr_blits.c +33
-0@@ -47,6 +47,7 @@#include <sys/time.h> #include <sys/mman.h> #include <signal.h> +#include <pthread.h> #include "drm.h" #include "i915_drm.h" @@ -1107,6 +1108,56 @@ static int test_unmap_cycles(int fd, int expected)return 0 ; } +static volatile int stop_mm_stress_thread; +static void *mm_stress_thread (void *data) +{ +void *ptr; +int ret; + +while (!stop_mm_stress_thread) { + ptr =mmap (NULL ,PAGE_SIZE ,PROT_READ |PROT_WRITE , +MAP_ANONYMOUS |MAP_PRIVATE ,-1 ,0 ); +assert (ptr !=MAP_FAILED ); + ret =munmap (ptr,PAGE_SIZE ); +assert (ret ==0 ); + } + +return NULL ; +} + +static int test_stress_mm (int fd) +{ +int ret; +pthread_t t; +unsigned int loops =100000 ; +uint32_t handle; +void *ptr; + +assert (posix_memalign (&ptr,PAGE_SIZE ,PAGE_SIZE ) ==0 ); + + ret =pthread_create (&t,NULL , mm_stress_thread,NULL ); +assert (ret ==0 ); + +while (loops--) { + ret =gem_userptr (fd, ptr,PAGE_SIZE ,0 , &handle);
tests/gem_userptr_blits.c static int test_unmap_cycles(int fd, int expected) · line 1153
Quoted 10 lines
tests/gem_userptr_blits.c +10
-0+assert (ret ==0 ); + +gem_close (fd, handle); + } + + stop_mm_stress_thread =1 ; + +free (ptr); + + ret =pthread_cancel (t);
You don't have any cancellation points in the loop. (mmap may or may not be, it is not required to be.)
But rather than use a global, just pass a pointer to a local struct.
Oh, and igt_assert. But kill the asserts in mm_stress_thread() first. -Chris
Signature · 1 line
Chris Wilson, Intel Open Source Technology Centre
Quoted 94 lines · Chris Wilson
Quoted 79 lines · Tvrtko Ursulin
From: Tvrtko Ursulin <[email protected]>
Userptr v23 was not thread safe against memory map operations and object creation from separate threads. MMU notifier callback would get triggered on a partially constructed object causing a NULL pointer dereference.
This test excercises that path a bit. In my testing it would trigger it every time and easily, but unfortunately a test pass here does not guarantee the absence of the race.
Signed-off-by Tvrtko Ursulin <[email protected]>Cc Chris Wilson <[email protected]>--- tests/Makefile.am | 2 ++ tests/gem_userptr_blits.c | 54 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 56 insertions(+)tests/Makefile.am +2
-0@@ -65,6 +65,8 @@ prime_self_import_CFLAGS = $(AM_CFLAGS) $(THREAD_CFLAGS) prime_self_import_LDADD = $(LDADD) -lpthread gen7_forcewake_mt_CFLAGS = $(AM_CFLAGS) $(THREAD_CFLAGS) gen7_forcewake_mt_LDADD = $(LDADD) -lpthread +gem_userptr_blits_CFLAGS = $(AM_CFLAGS) $(THREAD_CFLAGS) +gem_userptr_blits_LDADD = $(LDADD) -lpthread gem_wait_render_timeout_LDADD = $(LDADD) -lrt kms_flip_LDADD = $(LDADD) -lrt -lpthreadtests/gem_userptr_blits.c +33
-0@@ -47,6 +47,7 @@#include <sys/time.h> #include <sys/mman.h> #include <signal.h> +#include <pthread.h> #include "drm.h" #include "i915_drm.h" @@ -1107,6 +1108,56 @@ static int test_unmap_cycles(int fd, int expected)return 0 ; } +static volatile int stop_mm_stress_thread; +static void *mm_stress_thread (void *data) +{ +void *ptr; +int ret; + +while (!stop_mm_stress_thread) { + ptr =mmap (NULL ,PAGE_SIZE ,PROT_READ |PROT_WRITE , +MAP_ANONYMOUS |MAP_PRIVATE ,-1 ,0 ); +assert (ptr !=MAP_FAILED ); + ret =munmap (ptr,PAGE_SIZE ); +assert (ret ==0 ); + } + +return NULL ; +} + +static int test_stress_mm (int fd) +{ +int ret; +pthread_t t; +unsigned int loops =100000 ; +uint32_t handle; +void *ptr; + +assert (posix_memalign (&ptr,PAGE_SIZE ,PAGE_SIZE ) ==0 ); + + ret =pthread_create (&t,NULL , mm_stress_thread,NULL ); +assert (ret ==0 ); + +while (loops--) { + ret =gem_userptr (fd, ptr,PAGE_SIZE ,0 , &handle);tests/gem_userptr_blits.c static int test_unmap_cycles(int fd, int expected) · line 1153
Quoted 10 lines
tests/gem_userptr_blits.c +10
-0+assert (ret ==0 ); + +gem_close (fd, handle); + } + + stop_mm_stress_thread =1 ; + +free (ptr); + + ret =pthread_cancel (t);You don't have any cancellation points in the loop. (mmap may or may not be, it is not required to be.)
Quoted 1 line
But rather than use a global, just pass a pointer to a local struct.
It doesn't need both a cancellation point and a flag. Should I just add pthread_testcancel in the loop and not have any flag at all?
Quoted 1 line
Oh, and
igt_assert. But kill the asserts inmm_stress_thread()first.
Why remove completely? My thinking was to use assert vs igt_assert to distinguish between assumptions about system behaviour, and igt_assert for assertions about tested functionality.
Tvrtko
Quoted 7 lines
Quoted 4 lines
You don't have any cancellation points in the loop. (mmap may or may not be, it is not required to be.)
But rather than use a global, just pass a pointer to a local struct.
It doesn't need both a cancellation point and a flag. Should I just add
pthread_testcancelin the loop and not have any flag at all?
testcancel also neatly avoids the handwavely lack of mb().
Quoted 5 lines
Quoted 1 line
Oh, and
igt_assert. But kill the asserts inmm_stress_thread()first.Why remove completely? My thinking was to use assert vs
igt_assertto distinguish between assumptions about system behaviour, andigt_assertfor assertions about tested functionality.
If the assert fires you make the igt test runner angry. Might as well report a test failure rather than break down completely. -Chris
Signature · 1 line
Chris Wilson, Intel Open Source Technology Centre
Quoted 9 lines · Chris Wilson
Quoted 7 lines
Quoted 4 lines
You don't have any cancellation points in the loop. (mmap may or may not be, it is not required to be.)
But rather than use a global, just pass a pointer to a local struct.
It doesn't need both a cancellation point and a flag. Should I just add
pthread_testcancelin the loop and not have any flag at all?testcancel also neatly avoids the handwavely lack of
mb().
Barrier for what? But it doesn't matter, I'll re-spin with testcancel.
Quoted 8 lines
Quoted 5 lines
Quoted 1 line
Oh, and
igt_assert. But kill the asserts inmm_stress_thread()first.Why remove completely? My thinking was to use assert vs
igt_assertto distinguish between assumptions about system behaviour, andigt_assertfor assertions about tested functionality.If the assert fires you make the igt test runner angry. Might as well report a test failure rather than break down completely.
I am not familiar with the test runner, but if it cannot handle a test failing in a way other than it expects it so it deserves to be angry. :) But OK, I'll change it.
Tvrtko
Quoted 4 lines · Tvrtko Ursulin
Quoted 3 lines · Chris Wilson
Quoted 3 lines
Quoted 3 lines
You don't have any cancellation points in the loop. (mmap may or may not be, it is not required to be.)
Quoted 8 lines
Quoted 6 lines
Quoted 4 lines
Quoted 1 line
But rather than use a global, just pass a pointer to a local struct.
It doesn't need both a cancellation point and a flag. Should I just add
pthread_testcancelin the loop and not have any flag at all?testcancel also neatly avoids the handwavely lack of
mb().Barrier for what? But it doesn't matter, I'll re-spin with testcancel.
It just makes an assumption that the compiler and processor don't skip the read. Since it so simple to be pedagolically correct, it seems pointless to leave it using volatile.
Quoted 6 lines
Quoted 6 lines
Quoted 5 lines
Quoted 1 line
Oh, and
igt_assert. But kill the asserts inmm_stress_thread()first.Why remove completely? My thinking was to use assert vs
igt_assertto distinguish between assumptions about system behaviour, andigt_assertfor assertions about tested functionality.
Quoted 6 lines
Quoted 2 lines
If the assert fires you make the igt test runner angry. Might as well report a test failure rather than break down completely.
I am not familiar with the test runner, but if it cannot handle a test failing in a way other than it expects it so it deserves to be angry. :) But OK, I'll change it.
Actualy the SIGABRT will be delivered to the thread so you just get an ugly assert and a PASS if you do not propagate the failure... -Chris
Signature · 1 line
Chris Wilson, Intel Open Source Technology Centre
Unfortunately Android threads do not support cancel and testcancel, so this Test cannot build for android.
Do we really need a cancellation point, since we don't need to cancel the thread. Tvrtko's original solution seemed workable, if a bit less polished.
Tim
Quoted 50 lines
-----Original Message-----
From: Intel-gfx [mailto:[email protected]] On Behalf Of Chris Wilson
Sent: Monday, July 14, 2014 2:28 PM
To: Tvrtko Ursulin
Cc: [email protected]
Subject: Re: [Intel-gfx] [PATCH] tests/gem_userptr_blits: Race between object creation and multi-threaded mm opsQuoted 4 lines · Tvrtko Ursulin
Quoted 3 lines · Chris Wilson
Quoted 3 lines
Quoted 3 lines
You don't have any cancellation points in the loop. (mmap may or may not be, it is not required to be.)
Quoted 8 lines
Quoted 6 lines
Quoted 4 lines
Quoted 1 line
But rather than use a global, just pass a pointer to a local struct.
It doesn't need both a cancellation point and a flag. Should I just add
pthread_testcancelin the loop and not have any flag at all?testcancel also neatly avoids the handwavely lack of
mb().Barrier for what? But it doesn't matter, I'll re-spin with testcancel.
It just makes an assumption that the compiler and processor don't skip the read. Since it so simple to be pedagolically correct, it seems pointless to leave it using volatile.
Quoted 6 lines
Quoted 6 lines
Quoted 5 lines
Quoted 1 line
Oh, and
igt_assert. But kill the asserts inmm_stress_thread()first.Why remove completely? My thinking was to use assert vs
igt_assertto distinguish between assumptions about system behaviour, andigt_assertfor assertions about tested functionality.Quoted 6 lines
Quoted 2 lines
If the assert fires you make the igt test runner angry. Might as well report a test failure rather than break down completely.
I am not familiar with the test runner, but if it cannot handle a test failing in a way other than it expects it so it deserves to be angry. :) But OK, I'll change it.
Actualy the SIGABRT will be delivered to the thread so you just get an ugly assert and a PASS if you do not propagate the failure...
-Chris--
Chris Wilson, Intel Open Source Technology Centre
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 4 lines · Tim
Unfortunately Android threads do not support cancel and testcancel, so this Test cannot build for android.
Do we really need a cancellation point, since we don't need to cancel the thread. Tvrtko's original solution seemed workable, if a bit less polished.
Solution with a flag is fine in my opinion, but I also need to get rid of asserts in the thread. This is was Chris was pointing out, I always forget that threads have too much independence so SIGBART in a thread won't kill the process. I've put it on my TODO for the lower priority tasks, since I would still like to propagate any failures in the thread to subtest fail.
Tvrtko
PATCH 1/1 tests/gem_userptr_blits: Race between object creation and multi-threaded mm ops
In reply to Tvrtko UrsulinFrom: Tvrtko Ursulin <[email protected]>
Userptr v23 was not thread safe against memory map operations and object creation from separate threads. MMU notifier callback would get triggered on a partially constructed object causing a NULL pointer dereference.
This test excercises that path a bit. In my testing it would trigger it every time and easily, but unfortunately a test pass here does not guarantee the absence of the race.
v2: Added explicit cancellation point and removed the stop flag.
Use only igt_assert().
--- tests/Makefile.am | 2 ++ tests/gem_userptr_blits.c | 51 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 53 insertions(+)
tests/Makefile.am +2 -0
@@ -65,6 +65,8 @@ prime_self_import_CFLAGS = $(AM_CFLAGS) $(THREAD_CFLAGS) prime_self_import_LDADD = $(LDADD) -lpthread gen7_forcewake_mt_CFLAGS = $(AM_CFLAGS) $(THREAD_CFLAGS) gen7_forcewake_mt_LDADD = $(LDADD) -lpthread +gem_userptr_blits_CFLAGS = $(AM_CFLAGS) $(THREAD_CFLAGS) +gem_userptr_blits_LDADD = $(LDADD) -lpthread gem_wait_render_timeout_LDADD = $(LDADD) -lrt kms_flip_LDADD = $(LDADD) -lrt -lpthread
tests/gem_userptr_blits.c +51 -0
69 lines not on this page · raw message
Signature · 1 line
1.9.3