tools/testing/selftests/filesystems/eventfd/eventfd_test.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 #define _GNU_SOURCE
   4 #include <errno.h>
   5 #include <fcntl.h>
   6 #include <asm/unistd.h>
   7 #include <linux/time_types.h>
   8 #include <unistd.h>
   9 #include <assert.h>
  10 #include <signal.h>
  11 #include <pthread.h>
  12 #include <sys/epoll.h>
  13 #include <sys/eventfd.h>
  14 #include "../../kselftest_harness.h"
  15
  16 #define EVENTFD_TEST_ITERATIONS 100000UL
  17
  18 struct error {
  19         int  code;
  20         char msg[512];
  21 };
  22
  23 static int error_set(struct error *err, int code, const char *fmt, ...)
  24 {
  25         va_list args;
  26         int r;
  27
  28         if (code == 0 || !err || err->code != 0)
  29                 return code;
  30
  31         err->code = code;
  32         va_start(args, fmt);
  33         r = vsnprintf(err->msg, sizeof(err->msg), fmt, args);
  34         assert((size_t)r < sizeof(err->msg));
  35         va_end(args);
  36
  37         return code;
  38 }
  39
  40 static inline int sys_eventfd2(unsigned int count, int flags)
  41 {
  42         return syscall(__NR_eventfd2, count, flags);
  43 }
  44
  45 TEST(eventfd_check_flag_rdwr)
  46 {
  47         int fd, flags;
  48
  49         fd = sys_eventfd2(0, 0);
  50         ASSERT_GE(fd, 0);
  51
  52         flags = fcntl(fd, F_GETFL);
  53         // since the kernel automatically added O_RDWR.
  54         EXPECT_EQ(flags, O_RDWR);
  55
  56         close(fd);
  57 }
  58
  59 TEST(eventfd_check_flag_cloexec)
  60 {
  61         int fd, flags;
  62
  63         fd = sys_eventfd2(0, EFD_CLOEXEC);
  64         ASSERT_GE(fd, 0);
  65
  66         flags = fcntl(fd, F_GETFD);
  67         ASSERT_GT(flags, -1);
  68         EXPECT_EQ(flags, FD_CLOEXEC);
  69
  70         close(fd);
  71 }
  72
  73 TEST(eventfd_check_flag_nonblock)
  74 {
  75         int fd, flags;
  76
  77         fd = sys_eventfd2(0, EFD_NONBLOCK);
  78         ASSERT_GE(fd, 0);
  79
  80         flags = fcntl(fd, F_GETFL);
  81         ASSERT_GT(flags, -1);
  82         EXPECT_EQ(flags & EFD_NONBLOCK, EFD_NONBLOCK);
  83         EXPECT_EQ(flags & O_RDWR, O_RDWR);
  84
  85         close(fd);
  86 }
  87
  88 TEST(eventfd_chek_flag_cloexec_and_nonblock)
  89 {
  90         int fd, flags;
  91
  92         fd = sys_eventfd2(0, EFD_CLOEXEC|EFD_NONBLOCK);
  93         ASSERT_GE(fd, 0);
  94
  95         flags = fcntl(fd, F_GETFL);
  96         ASSERT_GT(flags, -1);
  97         EXPECT_EQ(flags & EFD_NONBLOCK, EFD_NONBLOCK);
  98         EXPECT_EQ(flags & O_RDWR, O_RDWR);
  99
 100         flags = fcntl(fd, F_GETFD);
 101         ASSERT_GT(flags, -1);
 102         EXPECT_EQ(flags, FD_CLOEXEC);
 103
 104         close(fd);
 105 }
 106
 107 static inline void trim_newline(char *str)
 108 {
 109         char *pos = strrchr(str, '\n');
 110
 111         if (pos)
 112                 *pos = '\0';
 113 }
 114
 115 static int verify_fdinfo(int fd, struct error *err, const char *prefix,
 116                 size_t prefix_len, const char *expect, ...)
 117 {
 118         char buffer[512] = {0, };
 119         char path[512] = {0, };
 120         va_list args;
 121         FILE *f;
 122         char *line = NULL;
 123         size_t n = 0;
 124         int found = 0;
 125         int r;
 126
 127         va_start(args, expect);
 128         r = vsnprintf(buffer, sizeof(buffer), expect, args);
 129         assert((size_t)r < sizeof(buffer));
 130         va_end(args);
 131
 132         snprintf(path, sizeof(path), "/proc/self/fdinfo/%d", fd);
 133         f = fopen(path, "re");
 134         if (!f)
 135                 return error_set(err, -1, "fdinfo open failed for %d", fd);
 136
 137         while (getline(&line, &n, f) != -1) {
 138                 char *val;
 139
 140                 if (strncmp(line, prefix, prefix_len))
 141                         continue;
 142
 143                 found = 1;
 144
 145                 val = line + prefix_len;
 146                 r = strcmp(val, buffer);
 147                 if (r != 0) {
 148                         trim_newline(line);
 149                         trim_newline(buffer);
 150                         error_set(err, -1, "%s '%s' != '%s'",
 151                                   prefix, val, buffer);
 152                 }
 153                 break;
 154         }
 155
 156         free(line);
 157         fclose(f);
 158
 159         if (found == 0)
 160                 return error_set(err, -1, "%s not found for fd %d",
 161                                  prefix, fd);
 162
 163         return 0;
 164 }
 165
 166 TEST(eventfd_check_flag_semaphore)
 167 {
 168         struct error err = {0};
 169         int fd, ret;
 170
 171         fd = sys_eventfd2(0, EFD_SEMAPHORE);
 172         ASSERT_GE(fd, 0);
 173
 174         ret = fcntl(fd, F_GETFL);
 175         ASSERT_GT(ret, -1);
 176         EXPECT_EQ(ret & O_RDWR, O_RDWR);
 177
 178         // The semaphore could only be obtained from fdinfo.
 179         ret = verify_fdinfo(fd, &err, "eventfd-semaphore: ", 19, "1\n");
 180         if (ret != 0)
 181                 ksft_print_msg("eventfd-semaphore check failed, msg: %s\n",
 182                                 err.msg);
 183         EXPECT_EQ(ret, 0);
 184
 185         close(fd);
 186 }
 187
 188 /*
 189  * A write(2) fails with the error EINVAL if the size of the supplied buffer
 190  * is less than 8 bytes, or if an attempt is made to write the value
 191  * 0xffffffffffffffff.
 192  */
 193 TEST(eventfd_check_write)
 194 {
 195         uint64_t value = 1;
 196         ssize_t size;
 197         int fd;
 198
 199         fd = sys_eventfd2(0, 0);
 200         ASSERT_GE(fd, 0);
 201
 202         size = write(fd, &value, sizeof(int));
 203         EXPECT_EQ(size, -1);
 204         EXPECT_EQ(errno, EINVAL);
 205
 206         size = write(fd, &value, sizeof(value));
 207         EXPECT_EQ(size, sizeof(value));
 208
 209         value = (uint64_t)-1;
 210         size = write(fd, &value, sizeof(value));
 211         EXPECT_EQ(size, -1);
 212         EXPECT_EQ(errno, EINVAL);
 213
 214         close(fd);
 215 }
 216
 217 /*
 218  * A read(2) fails with the error EINVAL if the size of the supplied buffer is
 219  * less than 8 bytes.
 220  */
 221 TEST(eventfd_check_read)
 222 {
 223         uint64_t value;
 224         ssize_t size;
 225         int fd;
 226
 227         fd = sys_eventfd2(1, 0);
 228         ASSERT_GE(fd, 0);
 229
 230         size = read(fd, &value, sizeof(int));
 231         EXPECT_EQ(size, -1);
 232         EXPECT_EQ(errno, EINVAL);
 233
 234         size = read(fd, &value, sizeof(value));
 235         EXPECT_EQ(size, sizeof(value));
 236         EXPECT_EQ(value, 1);
 237
 238         close(fd);
 239 }
 240
 241
 242 /*
 243  * If EFD_SEMAPHORE was not specified and the eventfd counter has a nonzero
 244  * value, then a read(2) returns 8 bytes containing that value, and the
 245  * counter's value is reset to zero.
 246  * If the eventfd counter is zero at the time of the call to read(2), then the
 247  * call fails with the error EAGAIN if the file descriptor has been made nonblocking.
 248  */
 249 TEST(eventfd_check_read_with_nonsemaphore)
 250 {
 251         uint64_t value;
 252         ssize_t size;
 253         int fd;
 254         int i;
 255
 256         fd = sys_eventfd2(0, EFD_NONBLOCK);
 257         ASSERT_GE(fd, 0);
 258
 259         value = 1;
 260         for (i = 0; i < EVENTFD_TEST_ITERATIONS; i++) {
 261                 size = write(fd, &value, sizeof(value));
 262                 EXPECT_EQ(size, sizeof(value));
 263         }
 264
 265         size = read(fd, &value, sizeof(value));
 266         EXPECT_EQ(size, sizeof(uint64_t));
 267         EXPECT_EQ(value, EVENTFD_TEST_ITERATIONS);
 268
 269         size = read(fd, &value, sizeof(value));
 270         EXPECT_EQ(size, -1);
 271         EXPECT_EQ(errno, EAGAIN);
 272
 273         close(fd);
 274 }
 275
 276 /*
 277  * If EFD_SEMAPHORE was specified and the eventfd counter has a nonzero value,
 278  * then a read(2) returns 8 bytes containing the value 1, and the counter's
 279  * value is decremented by 1.
 280  * If the eventfd counter is zero at the time of the call to read(2), then the
 281  * call fails with the error EAGAIN if the file descriptor has been made nonblocking.
 282  */
 283 TEST(eventfd_check_read_with_semaphore)
 284 {
 285         uint64_t value;
 286         ssize_t size;
 287         int fd;
 288         int i;
 289
 290         fd = sys_eventfd2(0, EFD_SEMAPHORE|EFD_NONBLOCK);
 291         ASSERT_GE(fd, 0);
 292
 293         value = 1;
 294         for (i = 0; i < EVENTFD_TEST_ITERATIONS; i++) {
 295                 size = write(fd, &value, sizeof(value));
 296                 EXPECT_EQ(size, sizeof(value));
 297         }
 298
 299         for (i = 0; i < EVENTFD_TEST_ITERATIONS; i++) {
 300                 size = read(fd, &value, sizeof(value));
 301                 EXPECT_EQ(size, sizeof(value));
 302                 EXPECT_EQ(value, 1);
 303         }
 304
 305         size = read(fd, &value, sizeof(value));
 306         EXPECT_EQ(size, -1);
 307         EXPECT_EQ(errno, EAGAIN);
 308
 309         close(fd);
 310 }
 311
 312 TEST_HARNESS_MAIN