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
313
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.