xref: /linux/tools/testing/selftests/filesystems/eventfd/eventfd_test.c (revision 55d0969c451159cff86949b38c39171cab962069)
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