github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-07-27 09:36:22 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

selftests/user_events: Wait for deferred event teardown after unregister

Browse Source 
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.

Link: https://patch.msgid.link/20260707180240.2887081-1-michael.bommarito@gmail.com
Assisted-by: Claude:claude-opus-4-8
Signed-off-by: Michael Bommarito <michael.bommarito@gmail.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
This commit is contained in:
Michael Bommarito 2026-07-07 14:02:40 -04:00 committed by Steven Rostedt
parent 05074bb90a
commit 42e74d8f21
2 changed files with 51 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
tools/testing/selftests/user_events/abi_test.c
View File

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

26
tools/testing/selftests/user_events/perf_test.c
View File

@ -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) {