selftests/user_events: wait for deferred event teardown after unregister
PATCH v3 1/1 selftests/user_events: wait for deferred event teardown after unregister
Unregistering a user event now defers the drop of the enabler's event reference (and the freeing of the enabler) past an RCU grace period. As a result DIAG_IOCSDEL can transiently fail with -EBUSY while that last reference is still being dropped, where it previously succeeded immediately.
Two tests assumed the delete takes effect the instant the unregister returns:
- abi_test "flags" deletes the event right after disabling it.
- perf_test's fixture teardown clear() deletes __test_event before the next test registers the same name; a stale event makes the following registration fail with -EADDRINUSE.
Retry the delete until it succeeds (or the event is already gone) with a bounded wait, matching the existing wait_for_delete() idiom in the same suite, so the tests are robust to the deferred teardown.
---
This resends only the selftest patch; the tracing/user_events fix that was patch 1/2 of the v2 series is unchanged and being applied separately.
v2 -> v3:
- abi_test wait_for_event_delete(): only retry the delete on -EBUSY, treat an already-deleted event (-ENOENT) as success, and return any other error immediately instead of spinning for the full 10s timeout. perf_test's clear() already discriminated on errno this way; the two now match. Reported by Sashiko automated review.
.../testing/selftests/user_events/abi_test.c | 29 ++++++++++++++++++- .../testing/selftests/user_events/perf_test.c | 26 +++++++++++++++-- 2 files changed, 51 insertions(+), 4 deletions(-)
tools/testing/selftests/user_events/abi_test.c +28 -1
@@ -132,6 +132,33 @@ static int event_delete(void)return ret; } +/* +* Deleting an event drops its last reference, but an unregister may defer +* that put (and the freeing of the associated enabler) past an RCU grace +* period. The delete can therefore transiently fail with -EBUSY while the +* previous reference is still being dropped. Retry only on that transient +* failure; treat an already-deleted event (-ENOENT) as success and return +* any other error immediately rather than spinning for the full timeout. +*/ +static int wait_for_event_delete (void ) +{ +int i, ret; + +for (i =0 ; i <10000 ; ++i) { + ret =event_delete (); + +if (ret ==0 || errno ==ENOENT ) +return 0 ; + +if (errno !=EBUSY ) +return ret; + +usleep (1000 ); + } + +return ret; +} +static int reg_enable_multi (void *enable,int size,int bit,int flags,char *args) {
@@ -262,7 +289,7 @@ TEST_F(user, flags) {ASSERT_TRUE (event_exists ());/* Ensure we can delete it */ -ASSERT_EQ (0 ,event_delete ()); +ASSERT_EQ (0 ,wait_for_event_delete ());/* USER_EVENT_REG_MAX or above is not allowed */ ASSERT_EQ(-1, reg_enable_flags(&self->check, sizeof(int), 0,
tools/testing/selftests/user_events/perf_test.c +23 -3
@@ -85,6 +85,7 @@ static int get_offset(void)static int clear (int *check) {struct user_unreg unreg = {0 }; +int i, ret; unreg.size =sizeof (unreg); unreg.disable_bit =31 ;
@@ -99,13 +100,32 @@ static int clear(int *check)if (errno !=ENOENT )return -1 ; -if (ioctl (fd,DIAG_IOCSDEL ,"__test_event" ) ==-1 ) -if (errno !=ENOENT ) +/* +* Deleting the event drops its last reference, but the unregister +* above defers that put (and the freeing of the enabler) past an RCU +* grace period. The delete can therefore transiently fail with -EBUSY +* until that reference is dropped. Retry for up to ~10 seconds so the +* event is actually gone before the next test registers the same name. +*/ +for (i =0 ; i <10000 ; ++i) { + ret =ioctl (fd,DIAG_IOCSDEL ,"__test_event" ); + +if (ret ==0 || errno ==ENOENT ) { + ret =0 ; +break ; + } + +if (errno !=EBUSY ) { +close (fd);return -1 ; + } + +usleep (1000 ); + }close (fd); -return 0 ; +return ret; }FIXTURE (user) {
Signature · 1 line
2.53.0