| // SPDX-License-Identifier: GPL-2.0 | |
| #define _GNU_SOURCE | |
| #include <errno.h> | |
| #include <fcntl.h> | |
| #include <asm/unistd.h> | |
| #include <linux/time_types.h> | |
| #include <unistd.h> | |
| #include <assert.h> | |
| #include <signal.h> | |
| #include <pthread.h> | |
| #include <sys/epoll.h> | |
| #include <sys/eventfd.h> | |
| #include "kselftest_harness.h" | |
| #define EVENTFD_TEST_ITERATIONS 100000UL | |
| struct error { | |
| int code; | |
| char msg[512]; | |
| }; | |
| static int error_set(struct error *err, int code, const char *fmt, ...) | |
| { | |
| va_list args; | |
| int r; | |
| if (code == 0 || !err || err->code != 0) | |
| return code; | |
| err->code = code; | |
| va_start(args, fmt); | |
| r = vsnprintf(err->msg, sizeof(err->msg), fmt, args); | |
| assert((size_t)r < sizeof(err->msg)); | |
| va_end(args); | |
| return code; | |
| } | |
| static inline int sys_eventfd2(unsigned int count, int flags) | |
| { | |
| return syscall(__NR_eventfd2, count, flags); | |
| } | |
| TEST(eventfd_check_flag_rdwr) | |
| { | |
| int fd, flags; | |
| fd = sys_eventfd2(0, 0); | |
| ASSERT_GE(fd, 0); | |
| flags = fcntl(fd, F_GETFL); | |
| // The kernel automatically adds the O_RDWR flag. | |
| EXPECT_EQ(flags, O_RDWR); | |
| close(fd); | |
| } | |
| TEST(eventfd_check_flag_cloexec) | |
| { | |
| int fd, flags; | |
| fd = sys_eventfd2(0, EFD_CLOEXEC); | |
| ASSERT_GE(fd, 0); | |
| flags = fcntl(fd, F_GETFD); | |
| ASSERT_GT(flags, -1); | |
| EXPECT_EQ(flags, FD_CLOEXEC); | |
| close(fd); | |
| } | |
| TEST(eventfd_check_flag_nonblock) | |
| { | |
| int fd, flags; | |
| fd = sys_eventfd2(0, EFD_NONBLOCK); | |
| ASSERT_GE(fd, 0); | |
| flags = fcntl(fd, F_GETFL); | |
| ASSERT_GT(flags, -1); | |
| EXPECT_EQ(flags & EFD_NONBLOCK, EFD_NONBLOCK); | |
| EXPECT_EQ(flags & O_RDWR, O_RDWR); | |
| close(fd); | |
| } | |
| TEST(eventfd_check_flag_cloexec_and_nonblock) | |
| { | |
| int fd, flags; | |
| fd = sys_eventfd2(0, EFD_CLOEXEC|EFD_NONBLOCK); | |
| ASSERT_GE(fd, 0); | |
| flags = fcntl(fd, F_GETFL); | |
| ASSERT_GT(flags, -1); | |
| EXPECT_EQ(flags & EFD_NONBLOCK, EFD_NONBLOCK); | |
| EXPECT_EQ(flags & O_RDWR, O_RDWR); | |
| flags = fcntl(fd, F_GETFD); | |
| ASSERT_GT(flags, -1); | |
| EXPECT_EQ(flags, FD_CLOEXEC); | |
| close(fd); | |
| } | |
| static inline void trim_newline(char *str) | |
| { | |
| char *pos = strrchr(str, '\n'); | |
| if (pos) | |
| *pos = '\0'; | |
| } | |
| static int verify_fdinfo(int fd, struct error *err, const char *prefix, | |
| size_t prefix_len, const char *expect, ...) | |
| { | |
| char buffer[512] = {0, }; | |
| char path[512] = {0, }; | |
| va_list args; | |
| FILE *f; | |
| char *line = NULL; | |
| size_t n = 0; | |
| int found = 0; | |
| int r; | |
| va_start(args, expect); | |
| r = vsnprintf(buffer, sizeof(buffer), expect, args); | |
| assert((size_t)r < sizeof(buffer)); | |
| va_end(args); | |
| snprintf(path, sizeof(path), "/proc/self/fdinfo/%d", fd); | |
| f = fopen(path, "re"); | |
| if (!f) | |
| return error_set(err, -1, "fdinfo open failed for %d", fd); | |
| while (getline(&line, &n, f) != -1) { | |
| char *val; | |
| if (strncmp(line, prefix, prefix_len)) | |
| continue; | |
| found = 1; | |
| val = line + prefix_len; | |
| r = strcmp(val, buffer); | |
| if (r != 0) { | |
| trim_newline(line); | |
| trim_newline(buffer); | |
| error_set(err, -1, "%s '%s' != '%s'", | |
| prefix, val, buffer); | |
| } | |
| break; | |
| } | |
| free(line); | |
| fclose(f); | |
| if (found == 0) | |
| return error_set(err, -1, "%s not found for fd %d", | |
| prefix, fd); | |
| return 0; | |
| } | |
| TEST(eventfd_check_flag_semaphore) | |
| { | |
| struct error err = {0}; | |
| int fd, ret; | |
| fd = sys_eventfd2(0, EFD_SEMAPHORE); | |
| ASSERT_GE(fd, 0); | |
| ret = fcntl(fd, F_GETFL); | |
| ASSERT_GT(ret, -1); | |
| EXPECT_EQ(ret & O_RDWR, O_RDWR); | |
| // The semaphore could only be obtained from fdinfo. | |
| ret = verify_fdinfo(fd, &err, "eventfd-semaphore: ", 19, "1\n"); | |
| if (ret != 0) | |
| ksft_print_msg("eventfd semaphore flag check failed: %s\n", err.msg); | |
| EXPECT_EQ(ret, 0); | |
| close(fd); | |
| } | |
| /* | |
| * A write(2) fails with the error EINVAL if the size of the supplied buffer | |
| * is less than 8 bytes, or if an attempt is made to write the value | |
| * 0xffffffffffffffff. | |
| */ | |
| TEST(eventfd_check_write) | |
| { | |
| uint64_t value = 1; | |
| ssize_t size; | |
| int fd; | |
| fd = sys_eventfd2(0, 0); | |
| ASSERT_GE(fd, 0); | |
| size = write(fd, &value, sizeof(int)); | |
| EXPECT_EQ(size, -1); | |
| EXPECT_EQ(errno, EINVAL); | |
| size = write(fd, &value, sizeof(value)); | |
| EXPECT_EQ(size, sizeof(value)); | |
| value = (uint64_t)-1; | |
| size = write(fd, &value, sizeof(value)); | |
| EXPECT_EQ(size, -1); | |
| EXPECT_EQ(errno, EINVAL); | |
| close(fd); | |
| } | |
| /* | |
| * A read(2) fails with the error EINVAL if the size of the supplied buffer is | |
| * less than 8 bytes. | |
| */ | |
| TEST(eventfd_check_read) | |
| { | |
| uint64_t value; | |
| ssize_t size; | |
| int fd; | |
| fd = sys_eventfd2(1, 0); | |
| ASSERT_GE(fd, 0); | |
| size = read(fd, &value, sizeof(int)); | |
| EXPECT_EQ(size, -1); | |
| EXPECT_EQ(errno, EINVAL); | |
| size = read(fd, &value, sizeof(value)); | |
| EXPECT_EQ(size, sizeof(value)); | |
| EXPECT_EQ(value, 1); | |
| close(fd); | |
| } | |
| /* | |
| * If EFD_SEMAPHORE was not specified and the eventfd counter has a nonzero | |
| * value, then a read(2) returns 8 bytes containing that value, and the | |
| * counter's value is reset to zero. | |
| * If the eventfd counter is zero at the time of the call to read(2), then the | |
| * call fails with the error EAGAIN if the file descriptor has been made nonblocking. | |
| */ | |
| TEST(eventfd_check_read_with_nonsemaphore) | |
| { | |
| uint64_t value; | |
| ssize_t size; | |
| int fd; | |
| int i; | |
| fd = sys_eventfd2(0, EFD_NONBLOCK); | |
| ASSERT_GE(fd, 0); | |
| value = 1; | |
| for (i = 0; i < EVENTFD_TEST_ITERATIONS; i++) { | |
| size = write(fd, &value, sizeof(value)); | |
| EXPECT_EQ(size, sizeof(value)); | |
| } | |
| size = read(fd, &value, sizeof(value)); | |
| EXPECT_EQ(size, sizeof(uint64_t)); | |
| EXPECT_EQ(value, EVENTFD_TEST_ITERATIONS); | |
| size = read(fd, &value, sizeof(value)); | |
| EXPECT_EQ(size, -1); | |
| EXPECT_EQ(errno, EAGAIN); | |
| close(fd); | |
| } | |
| /* | |
| * If EFD_SEMAPHORE was specified and the eventfd counter has a nonzero value, | |
| * then a read(2) returns 8 bytes containing the value 1, and the counter's | |
| * value is decremented by 1. | |
| * If the eventfd counter is zero at the time of the call to read(2), then the | |
| * call fails with the error EAGAIN if the file descriptor has been made nonblocking. | |
| */ | |
| TEST(eventfd_check_read_with_semaphore) | |
| { | |
| uint64_t value; | |
| ssize_t size; | |
| int fd; | |
| int i; | |
| fd = sys_eventfd2(0, EFD_SEMAPHORE|EFD_NONBLOCK); | |
| ASSERT_GE(fd, 0); | |
| value = 1; | |
| for (i = 0; i < EVENTFD_TEST_ITERATIONS; i++) { | |
| size = write(fd, &value, sizeof(value)); | |
| EXPECT_EQ(size, sizeof(value)); | |
| } | |
| for (i = 0; i < EVENTFD_TEST_ITERATIONS; i++) { | |
| size = read(fd, &value, sizeof(value)); | |
| EXPECT_EQ(size, sizeof(value)); | |
| EXPECT_EQ(value, 1); | |
| } | |
| size = read(fd, &value, sizeof(value)); | |
| EXPECT_EQ(size, -1); | |
| EXPECT_EQ(errno, EAGAIN); | |
| close(fd); | |
| } | |
| TEST_HARNESS_MAIN |