[LTP] [PATCH v7] fanotify22.c: handle multiple asynchronous error events
Wei Gao
wegao@suse.com
Tue Mar 31 13:18:39 CEST 2026
Since the introduction of the asynchronous fserror reporting framework
(kernel commit 81d2e13a57c9), fanotify22 has encountered sporadic failures
due to the non-deterministic nature of event delivery and merging:
1) tcase3 failure: A race condition occurs when the test reads the
notification fd between two events. Use a poll() and read() loop to wait
until the expected event.
2) tcase4 failure: The kernel may deliver errors as independent events
instead of a single merged event, since different worker kthread can
end up generating each event so they won't be merged. As suggested by
Jan Kara, this patch introduces a consolidate_events() helper. It iterates
through the event buffer, accumulates the error_count from all independent
events, and updates the first event's count in-place.
Reported-by: kernel test robot <oliver.sang@intel.com>
Closes: https://lore.kernel.org/oe-lkp/202602042124.87bd00e3-lkp@intel.com
Suggested-by: Jan Kara <jack@suse.cz>
Signed-off-by: Wei Gao <wegao@suse.com>
---
v6->v7:
- validation check to accept either error or error2 in check_error_event_info_error
.../kernel/syscalls/fanotify/fanotify22.c | 113 +++++++++++++++---
1 file changed, 96 insertions(+), 17 deletions(-)
diff --git a/testcases/kernel/syscalls/fanotify/fanotify22.c b/testcases/kernel/syscalls/fanotify/fanotify22.c
index e8002b160..f5d59b99d 100644
--- a/testcases/kernel/syscalls/fanotify/fanotify22.c
+++ b/testcases/kernel/syscalls/fanotify/fanotify22.c
@@ -28,6 +28,7 @@
#include "tst_test.h"
#include <sys/fanotify.h>
#include <sys/types.h>
+#include <poll.h>
#ifdef HAVE_SYS_FANOTIFY_H
#include "fanotify.h"
@@ -88,7 +89,6 @@ static void trigger_bad_link_lookup(void)
ret, BAD_LINK, errno, EUCLEAN);
}
-
static void tcase3_trigger(void)
{
trigger_bad_link_lookup();
@@ -104,6 +104,7 @@ static void tcase4_trigger(void)
static struct test_case {
char *name;
int error;
+ int error2;
unsigned int error_count;
struct fanotify_fid_t *fid;
void (*trigger_error)(void);
@@ -134,37 +135,79 @@ static struct test_case {
.trigger_error = &tcase4_trigger,
.error_count = 2,
.error = EFSCORRUPTED,
+ .error2 = ESHUTDOWN,
.fid = &bad_file_fid,
}
};
+static size_t consolidate_events(char *buf, size_t len, const struct test_case *ex)
+{
+ struct fanotify_event_metadata *metadata, *first = NULL;
+ struct fanotify_event_info_error *first_info = NULL;
+ unsigned int total_count = 0;
+ int event_num = 0;
+
+ for (metadata = (struct fanotify_event_metadata *)buf;
+ FAN_EVENT_OK(metadata, len);
+ metadata = FAN_EVENT_NEXT(metadata, len)) {
+
+ event_num++;
+ struct fanotify_event_info_error *info = get_event_info_error(metadata);
+
+ if (!info) {
+ tst_res(TFAIL, "Event [%d] missing error info", event_num);
+ continue;
+ }
+
+ if (info->error != ex->error && (ex->error2 == 0 || info->error != ex->error2)) {
+ tst_res(TFAIL, "Event [%d] unexpected errno (%d)",
+ event_num, info->error);
+ continue;
+ }
+
+ if (!first) {
+ first = metadata;
+ first_info = info;
+ }
+ total_count += info->error_count;
+
+ tst_res(TINFO, "Event [%d]: errno=%d, error_count=%d",
+ event_num, info->error, info->error_count);
+ }
+
+ if (first_info)
+ first_info->error_count = total_count;
+
+ return (first) ? first->event_len : 0;
+}
+
static int check_error_event_info_fid(struct fanotify_event_info_fid *fid,
const struct test_case *ex)
{
struct file_handle *fh = (struct file_handle *) &fid->handle;
if (memcmp(&fid->fsid, &ex->fid->fsid, sizeof(fid->fsid))) {
- tst_res(TFAIL, "%s: Received bad FSID type (%x...!=%x...)",
- ex->name, FSID_VAL_MEMBER(fid->fsid, 0),
+ tst_res(TFAIL, "Received bad FSID type (%x...!=%x...)",
+ FSID_VAL_MEMBER(fid->fsid, 0),
ex->fid->fsid.val[0]);
return 1;
}
if (fh->handle_type != ex->fid->handle.handle_type) {
- tst_res(TFAIL, "%s: Received bad file_handle type (%d!=%d)",
- ex->name, fh->handle_type, ex->fid->handle.handle_type);
+ tst_res(TFAIL, "Received bad file_handle type (%d!=%d)",
+ fh->handle_type, ex->fid->handle.handle_type);
return 1;
}
if (fh->handle_bytes != ex->fid->handle.handle_bytes) {
- tst_res(TFAIL, "%s: Received bad file_handle len (%d!=%d)",
- ex->name, fh->handle_bytes, ex->fid->handle.handle_bytes);
+ tst_res(TFAIL, "Received bad file_handle len (%d!=%d)",
+ fh->handle_bytes, ex->fid->handle.handle_bytes);
return 1;
}
if (memcmp(fh->f_handle, ex->fid->handle.f_handle, fh->handle_bytes)) {
- tst_res(TFAIL, "%s: Received wrong handle. "
- "Expected (%x...) got (%x...) ", ex->name,
+ tst_res(TFAIL, "Received wrong handle. "
+ "Expected (%x...) got (%x...) ",
*(int *)ex->fid->handle.f_handle, *(int *)fh->f_handle);
return 1;
}
@@ -177,14 +220,15 @@ static int check_error_event_info_error(struct fanotify_event_info_error *info_e
int fail = 0;
if (info_error->error_count != ex->error_count) {
- tst_res(TFAIL, "%s: Unexpected error_count (%d!=%d)",
- ex->name, info_error->error_count, ex->error_count);
+ tst_res(TFAIL, "Unexpected error_count (%d!=%d)",
+ info_error->error_count, ex->error_count);
fail++;
}
- if (info_error->error != ex->error) {
- tst_res(TFAIL, "%s: Unexpected error code value (%d!=%d)",
- ex->name, info_error->error, ex->error);
+ if (info_error->error != ex->error &&
+ (ex->error2 == 0 || info_error->error != ex->error2)) {
+ tst_res(TFAIL, "Unexpected error code value (%d!=%d)",
+ info_error->error, ex->error);
fail++;
}
@@ -248,19 +292,54 @@ static void check_event(char *buf, size_t len, const struct test_case *ex)
static void do_test(unsigned int i)
{
const struct test_case *tcase = &testcases[i];
- size_t read_len;
+ size_t read_len = 0;
+ struct pollfd pfd;
+ unsigned int accumulated_count = 0;
+
+ tst_res(TINFO, "Test case: %s", tcase->name);
SAFE_FANOTIFY_MARK(fd_notify, FAN_MARK_ADD|FAN_MARK_FILESYSTEM,
FAN_FS_ERROR, AT_FDCWD, MOUNT_PATH);
tcase->trigger_error();
- read_len = SAFE_READ(0, fd_notify, event_buf, BUF_SIZE);
+ pfd.fd = fd_notify;
+ pfd.events = POLLIN;
+
+ while (accumulated_count < tcase->error_count) {
+ if (poll(&pfd, 1, 5000) <= 0) {
+ tst_res(TFAIL, "Timeout waiting for events");
+ goto out;
+ }
+
+ if (BUF_SIZE - read_len < FAN_EVENT_METADATA_LEN)
+ tst_brk(TBROK, "Insufficient buffer space for next event");
+
+ char *current_pos = event_buf + read_len;
+ ssize_t ret = SAFE_READ(0, fd_notify, current_pos, BUF_SIZE - read_len);
+
+ struct fanotify_event_metadata *m =
+ (struct fanotify_event_metadata *)current_pos;
+ while (FAN_EVENT_OK(m, ret)) {
+ struct fanotify_event_info_error *e = get_event_info_error(m);
+
+ if (e)
+ accumulated_count += e->error_count;
+
+ read_len += m->event_len;
+ m = FAN_EVENT_NEXT(m, ret);
+ }
+ }
+
+ read_len = consolidate_events(event_buf, read_len, tcase);
+
+ check_event(event_buf, read_len, tcase);
+
+out:
SAFE_FANOTIFY_MARK(fd_notify, FAN_MARK_REMOVE|FAN_MARK_FILESYSTEM,
FAN_FS_ERROR, AT_FDCWD, MOUNT_PATH);
- check_event(event_buf, read_len, tcase);
/* Unmount and mount the filesystem to get it out of the error state */
SAFE_UMOUNT(MOUNT_PATH);
SAFE_MOUNT(tst_device->dev, MOUNT_PATH, tst_device->fs_type, 0, NULL);
--
2.52.0
More information about the ltp
mailing list