Skip to contentSkip to conversation

tests/gem_userptr_blits: Race between object creation and multi-threaded mm ops

PATCH In review Tvrtko Ursulin 3 participants 9 messages Jul 14, 2014 – Jul 18, 2014

lore
Share & tools
lore
#0 lore raw

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
index 2878624..e207509 100644
@@ -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
#1 lore raw
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.

---
 tests/Makefile.am         |  2 ++
 tests/gem_userptr_blits.c | 54 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 56 insertions(+)
tests/Makefile.am +2 -0
index 2878624..e207509 100644
@@ -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 +33 -0
index 2eb127f..0213868 100644
@@ -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
#2 lore raw
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.

---
  tests/Makefile.am         |  2 ++
  tests/gem_userptr_blits.c | 54 +++++++++++++++++++++++++++++++++++++++++++++++
  2 files changed, 56 insertions(+)
tests/Makefile.am +2 -0
index 2878624..e207509 100644
@@ -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 +33 -0
index 2eb127f..0213868 100644
@@ -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 in mm_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

#3 lore raw
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_testcancel in 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 in mm_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.

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
#4 lore raw
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_testcancel in 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 in mm_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.

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

#5 lore raw
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_testcancel in 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 in mm_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.

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
#6 lore raw

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 ops

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_testcancel in 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 in mm_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.

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

#7 lore raw
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

#8 lore raw

PATCH 1/1 tests/gem_userptr_blits: Race between object creation and multi-threaded mm ops

In reply to 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.

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
index 2878624..e207509 100644
@@ -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