|
160
|
1 /* Copyright libuv project contributors. All rights reserved.
|
|
|
2 *
|
|
|
3 * Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
4 * of this software and associated documentation files (the "Software"), to
|
|
|
5 * deal in the Software without restriction, including without limitation the
|
|
|
6 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
|
7 * sell copies of the Software, and to permit persons to whom the Software is
|
|
|
8 * furnished to do so, subject to the following conditions:
|
|
|
9 *
|
|
|
10 * The above copyright notice and this permission notice shall be included in
|
|
|
11 * all copies or substantial portions of the Software.
|
|
|
12 *
|
|
|
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
16 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
17 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
18 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
19 * IN THE SOFTWARE.
|
|
|
20 */
|
|
|
21
|
|
|
22 /* These tests are Unix only. */
|
|
|
23 #ifndef _WIN32
|
|
|
24
|
|
|
25 #include <unistd.h>
|
|
|
26 #include <sys/wait.h>
|
|
|
27 #include <sys/socket.h>
|
|
|
28 #include <string.h>
|
|
|
29
|
|
|
30 #ifdef __APPLE__
|
|
|
31 #include <TargetConditionals.h>
|
|
|
32 #endif
|
|
|
33
|
|
|
34 #include "uv.h"
|
|
|
35 #include "task.h"
|
|
|
36
|
|
|
37 static int timer_cb_called;
|
|
|
38 static int socket_cb_called;
|
|
|
39
|
|
|
40 static void timer_cb(uv_timer_t* timer) {
|
|
|
41 timer_cb_called++;
|
|
|
42 uv_close((uv_handle_t*) timer, NULL);
|
|
|
43 }
|
|
|
44
|
|
|
45
|
|
|
46 static int socket_cb_read_fd;
|
|
|
47 static int socket_cb_read_size;
|
|
|
48 static char socket_cb_read_buf[1024];
|
|
|
49
|
|
|
50
|
|
|
51 static void socket_cb(uv_poll_t* poll, int status, int events) {
|
|
|
52 ssize_t cnt;
|
|
|
53 socket_cb_called++;
|
|
|
54 ASSERT_OK(status);
|
|
|
55 printf("Socket cb got events %d\n", events);
|
|
|
56 ASSERT_EQ(UV_READABLE, (events & UV_READABLE));
|
|
|
57 if (socket_cb_read_fd) {
|
|
|
58 cnt = read(socket_cb_read_fd, socket_cb_read_buf, socket_cb_read_size);
|
|
|
59 ASSERT_EQ(cnt, socket_cb_read_size);
|
|
|
60 }
|
|
|
61 uv_close((uv_handle_t*) poll, NULL);
|
|
|
62 }
|
|
|
63
|
|
|
64
|
|
|
65 static void run_timer_loop_once(void) {
|
|
|
66 uv_loop_t loop;
|
|
|
67 uv_timer_t timer_handle;
|
|
|
68
|
|
|
69 ASSERT_OK(uv_loop_init(&loop));
|
|
|
70
|
|
|
71 timer_cb_called = 0; /* Reset for the child. */
|
|
|
72
|
|
|
73 ASSERT_OK(uv_timer_init(&loop, &timer_handle));
|
|
|
74 ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, 1, 0));
|
|
|
75 ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT));
|
|
|
76 ASSERT_EQ(1, timer_cb_called);
|
|
|
77 ASSERT_OK(uv_loop_close(&loop));
|
|
|
78 }
|
|
|
79
|
|
|
80
|
|
|
81 static void assert_wait_child(pid_t child_pid) {
|
|
|
82 pid_t waited_pid;
|
|
|
83 int child_stat;
|
|
|
84
|
|
|
85 waited_pid = waitpid(child_pid, &child_stat, 0);
|
|
|
86 printf("Waited pid is %d with status %d\n", waited_pid, child_stat);
|
|
|
87 if (waited_pid == -1) {
|
|
|
88 perror("Failed to wait");
|
|
|
89 }
|
|
|
90 ASSERT_EQ(child_pid, waited_pid);
|
|
|
91 ASSERT(WIFEXITED(child_stat)); /* Clean exit, not a signal. */
|
|
|
92 ASSERT(!WIFSIGNALED(child_stat));
|
|
|
93 ASSERT_OK(WEXITSTATUS(child_stat));
|
|
|
94 }
|
|
|
95
|
|
|
96
|
|
|
97 TEST_IMPL(fork_timer) {
|
|
|
98 /* Timers continue to work after we fork. */
|
|
|
99
|
|
|
100 /*
|
|
|
101 * Establish the loop before we fork to make sure that it
|
|
|
102 * has state to get reset after the fork.
|
|
|
103 */
|
|
|
104 pid_t child_pid;
|
|
|
105
|
|
|
106 run_timer_loop_once();
|
|
|
107 #if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH)
|
|
|
108 child_pid = -1;
|
|
|
109 #else
|
|
|
110 child_pid = fork();
|
|
|
111 #endif
|
|
|
112 ASSERT_NE(child_pid, -1);
|
|
|
113
|
|
|
114 if (child_pid != 0) {
|
|
|
115 /* parent */
|
|
|
116 assert_wait_child(child_pid);
|
|
|
117 } else {
|
|
|
118 /* child */
|
|
|
119 ASSERT_OK(uv_loop_fork(uv_default_loop()));
|
|
|
120 run_timer_loop_once();
|
|
|
121 }
|
|
|
122
|
|
|
123 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
124 return 0;
|
|
|
125 }
|
|
|
126
|
|
|
127
|
|
|
128 TEST_IMPL(fork_socketpair) {
|
|
|
129 /* A socket opened in the parent and accept'd in the
|
|
|
130 child works after a fork. */
|
|
|
131 pid_t child_pid;
|
|
|
132 int socket_fds[2];
|
|
|
133 uv_poll_t poll_handle;
|
|
|
134
|
|
|
135 /* Prime the loop. */
|
|
|
136 run_timer_loop_once();
|
|
|
137
|
|
|
138 ASSERT_OK(socketpair(AF_UNIX, SOCK_STREAM, 0, socket_fds));
|
|
|
139
|
|
|
140 /* Create the server watcher in the parent, use it in the child. */
|
|
|
141 ASSERT_OK(uv_poll_init(uv_default_loop(), &poll_handle, socket_fds[0]));
|
|
|
142
|
|
|
143 #if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH)
|
|
|
144 child_pid = -1;
|
|
|
145 #else
|
|
|
146 child_pid = fork();
|
|
|
147 #endif
|
|
|
148 ASSERT_NE(child_pid, -1);
|
|
|
149
|
|
|
150 if (child_pid != 0) {
|
|
|
151 /* parent */
|
|
|
152 ASSERT_EQ(3, send(socket_fds[1], "hi\n", 3, 0));
|
|
|
153 assert_wait_child(child_pid);
|
|
|
154 } else {
|
|
|
155 /* child */
|
|
|
156 ASSERT_OK(uv_loop_fork(uv_default_loop()));
|
|
|
157 ASSERT_OK(socket_cb_called);
|
|
|
158 ASSERT_OK(uv_poll_start(&poll_handle, UV_READABLE, socket_cb));
|
|
|
159 printf("Going to run the loop in the child\n");
|
|
|
160 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
|
|
|
161 ASSERT_EQ(1, socket_cb_called);
|
|
|
162 }
|
|
|
163
|
|
|
164 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
165 return 0;
|
|
|
166 }
|
|
|
167
|
|
|
168
|
|
|
169 TEST_IMPL(fork_socketpair_started) {
|
|
|
170 /* A socket opened in the parent and accept'd in the
|
|
|
171 child works after a fork, even if the watcher was already
|
|
|
172 started, and then stopped in the parent. */
|
|
|
173 pid_t child_pid;
|
|
|
174 int socket_fds[2];
|
|
|
175 int sync_pipe[2];
|
|
|
176 char sync_buf[1];
|
|
|
177 uv_poll_t poll_handle;
|
|
|
178
|
|
|
179 ASSERT_OK(pipe(sync_pipe));
|
|
|
180
|
|
|
181 /* Prime the loop. */
|
|
|
182 run_timer_loop_once();
|
|
|
183
|
|
|
184 ASSERT_OK(socketpair(AF_UNIX, SOCK_STREAM, 0, socket_fds));
|
|
|
185
|
|
|
186 /* Create and start the server watcher in the parent, use it in the child. */
|
|
|
187 ASSERT_OK(uv_poll_init(uv_default_loop(), &poll_handle, socket_fds[0]));
|
|
|
188 ASSERT_OK(uv_poll_start(&poll_handle, UV_READABLE, socket_cb));
|
|
|
189
|
|
|
190 /* Run the loop AFTER the poll watcher is registered to make sure it
|
|
|
191 gets passed to the kernel. Use NOWAIT and expect a non-zero
|
|
|
192 return to prove the poll watcher is active.
|
|
|
193 */
|
|
|
194 ASSERT_EQ(1, uv_run(uv_default_loop(), UV_RUN_NOWAIT));
|
|
|
195
|
|
|
196 #if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH)
|
|
|
197 child_pid = -1;
|
|
|
198 #else
|
|
|
199 child_pid = fork();
|
|
|
200 #endif
|
|
|
201 ASSERT_NE(child_pid, -1);
|
|
|
202
|
|
|
203 if (child_pid != 0) {
|
|
|
204 /* parent */
|
|
|
205 ASSERT_OK(uv_poll_stop(&poll_handle));
|
|
|
206 uv_close((uv_handle_t*)&poll_handle, NULL);
|
|
|
207 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
|
|
|
208 ASSERT_OK(socket_cb_called);
|
|
|
209 ASSERT_EQ(1, write(sync_pipe[1], "1", 1)); /* alert child */
|
|
|
210 ASSERT_EQ(3, send(socket_fds[1], "hi\n", 3, 0));
|
|
|
211
|
|
|
212 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
|
|
|
213 ASSERT_OK(socket_cb_called);
|
|
|
214
|
|
|
215 assert_wait_child(child_pid);
|
|
|
216 } else {
|
|
|
217 /* child */
|
|
|
218 printf("Child is %d\n", getpid());
|
|
|
219 ASSERT_EQ(1, read(sync_pipe[0], sync_buf, 1)); /* wait for parent */
|
|
|
220 ASSERT_OK(uv_loop_fork(uv_default_loop()));
|
|
|
221 ASSERT_OK(socket_cb_called);
|
|
|
222
|
|
|
223 printf("Going to run the loop in the child\n");
|
|
|
224 socket_cb_read_fd = socket_fds[0];
|
|
|
225 socket_cb_read_size = 3;
|
|
|
226 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
|
|
|
227 ASSERT_EQ(1, socket_cb_called);
|
|
|
228 printf("Buf %s\n", socket_cb_read_buf);
|
|
|
229 ASSERT_OK(strcmp("hi\n", socket_cb_read_buf));
|
|
|
230 }
|
|
|
231
|
|
|
232 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
233 return 0;
|
|
|
234 }
|
|
|
235
|
|
|
236
|
|
|
237 static int fork_signal_cb_called;
|
|
|
238
|
|
|
239 void fork_signal_to_child_cb(uv_signal_t* handle, int signum)
|
|
|
240 {
|
|
|
241 fork_signal_cb_called = signum;
|
|
|
242 uv_close((uv_handle_t*)handle, NULL);
|
|
|
243 }
|
|
|
244
|
|
|
245
|
|
|
246 TEST_IMPL(fork_signal_to_child) {
|
|
|
247 /* A signal handler installed before forking
|
|
|
248 is run only in the child when the child is signalled. */
|
|
|
249 uv_signal_t signal_handle;
|
|
|
250 pid_t child_pid;
|
|
|
251 int sync_pipe[2];
|
|
|
252 char sync_buf[1];
|
|
|
253
|
|
|
254 fork_signal_cb_called = 0; /* reset */
|
|
|
255
|
|
|
256 ASSERT_OK(pipe(sync_pipe));
|
|
|
257
|
|
|
258 /* Prime the loop. */
|
|
|
259 run_timer_loop_once();
|
|
|
260
|
|
|
261 ASSERT_OK(uv_signal_init(uv_default_loop(), &signal_handle));
|
|
|
262 ASSERT_OK(uv_signal_start(&signal_handle,
|
|
|
263 fork_signal_to_child_cb,
|
|
|
264 SIGUSR1));
|
|
|
265
|
|
|
266 #if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH)
|
|
|
267 child_pid = -1;
|
|
|
268 #else
|
|
|
269 child_pid = fork();
|
|
|
270 #endif
|
|
|
271 ASSERT_NE(child_pid, -1);
|
|
|
272
|
|
|
273 if (child_pid != 0) {
|
|
|
274 /* parent */
|
|
|
275 ASSERT_EQ(1, read(sync_pipe[0], sync_buf, 1)); /* wait for child */
|
|
|
276 ASSERT_OK(kill(child_pid, SIGUSR1));
|
|
|
277 /* Run the loop, make sure we don't get the signal. */
|
|
|
278 printf("Running loop in parent\n");
|
|
|
279 uv_unref((uv_handle_t*)&signal_handle);
|
|
|
280 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_NOWAIT));
|
|
|
281 ASSERT_OK(fork_signal_cb_called);
|
|
|
282 printf("Waiting for child in parent\n");
|
|
|
283 assert_wait_child(child_pid);
|
|
|
284 } else {
|
|
|
285 /* child */
|
|
|
286 ASSERT_OK(uv_loop_fork(uv_default_loop()));
|
|
|
287 ASSERT_EQ(1, write(sync_pipe[1], "1", 1)); /* alert parent */
|
|
|
288 /* Get the signal. */
|
|
|
289 ASSERT_NE(0, uv_loop_alive(uv_default_loop()));
|
|
|
290 printf("Running loop in child\n");
|
|
|
291 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_ONCE));
|
|
|
292 ASSERT_EQ(SIGUSR1, fork_signal_cb_called);
|
|
|
293 }
|
|
|
294
|
|
|
295 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
296 return 0;
|
|
|
297 }
|
|
|
298
|
|
|
299
|
|
|
300 TEST_IMPL(fork_signal_to_child_closed) {
|
|
|
301 /* A signal handler installed before forking
|
|
|
302 doesn't get received anywhere when the child is signalled,
|
|
|
303 but isnt running the loop. */
|
|
|
304 uv_signal_t signal_handle;
|
|
|
305 pid_t child_pid;
|
|
|
306 int sync_pipe[2];
|
|
|
307 int sync_pipe2[2];
|
|
|
308 char sync_buf[1];
|
|
|
309 int r;
|
|
|
310
|
|
|
311 fork_signal_cb_called = 0; /* reset */
|
|
|
312
|
|
|
313 ASSERT_OK(pipe(sync_pipe));
|
|
|
314 ASSERT_OK(pipe(sync_pipe2));
|
|
|
315
|
|
|
316 /* Prime the loop. */
|
|
|
317 run_timer_loop_once();
|
|
|
318
|
|
|
319 ASSERT_OK(uv_signal_init(uv_default_loop(), &signal_handle));
|
|
|
320 ASSERT_OK(uv_signal_start(&signal_handle,
|
|
|
321 fork_signal_to_child_cb,
|
|
|
322 SIGUSR1));
|
|
|
323
|
|
|
324 #if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH)
|
|
|
325 child_pid = -1;
|
|
|
326 #else
|
|
|
327 child_pid = fork();
|
|
|
328 #endif
|
|
|
329 ASSERT_NE(child_pid, -1);
|
|
|
330
|
|
|
331 if (child_pid != 0) {
|
|
|
332 /* parent */
|
|
|
333 printf("Wating on child in parent\n");
|
|
|
334 ASSERT_EQ(1, read(sync_pipe[0], sync_buf, 1)); /* wait for child */
|
|
|
335 printf("Parent killing child\n");
|
|
|
336 ASSERT_OK(kill(child_pid, SIGUSR1));
|
|
|
337 /* Run the loop, make sure we don't get the signal. */
|
|
|
338 printf("Running loop in parent\n");
|
|
|
339 uv_unref((uv_handle_t*)&signal_handle); /* so the loop can exit;
|
|
|
340 we *shouldn't* get any signals */
|
|
|
341 run_timer_loop_once(); /* but while we share a pipe, we do, so
|
|
|
342 have something active. */
|
|
|
343 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_ONCE));
|
|
|
344 printf("Signal in parent %d\n", fork_signal_cb_called);
|
|
|
345 ASSERT_OK(fork_signal_cb_called);
|
|
|
346 ASSERT_EQ(1, write(sync_pipe2[1], "1", 1)); /* alert child */
|
|
|
347 printf("Waiting for child in parent\n");
|
|
|
348 assert_wait_child(child_pid);
|
|
|
349 } else {
|
|
|
350 /* Child. Our signal handler should still be installed. */
|
|
|
351 ASSERT_OK(uv_loop_fork(uv_default_loop()));
|
|
|
352 printf("Checking loop in child\n");
|
|
|
353 ASSERT_NE(0, uv_loop_alive(uv_default_loop()));
|
|
|
354 printf("Alerting parent in child\n");
|
|
|
355 ASSERT_EQ(1, write(sync_pipe[1], "1", 1)); /* alert parent */
|
|
|
356 /* Don't run the loop. Wait for the parent to call us */
|
|
|
357 printf("Waiting on parent in child\n");
|
|
|
358 /* Wait for parent. read may fail if the parent tripped an ASSERT
|
|
|
359 and exited, so this ASSERT is generous.
|
|
|
360 */
|
|
|
361 r = read(sync_pipe2[0], sync_buf, 1);
|
|
|
362 ASSERT(-1 <= r && r <= 1);
|
|
|
363 ASSERT_OK(fork_signal_cb_called);
|
|
|
364 printf("Exiting child \n");
|
|
|
365 /* Note that we're deliberately not running the loop
|
|
|
366 * in the child, and also not closing the loop's handles,
|
|
|
367 * so the child default loop can't be cleanly closed.
|
|
|
368 * We need to explicitly exit to avoid an automatic failure
|
|
|
369 * in that case.
|
|
|
370 */
|
|
|
371 exit(0);
|
|
|
372 }
|
|
|
373
|
|
|
374 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
375 return 0;
|
|
|
376 }
|
|
|
377
|
|
|
378 static void fork_signal_cb(uv_signal_t* h, int s) {
|
|
|
379 fork_signal_cb_called = s;
|
|
|
380 }
|
|
|
381 static void empty_close_cb(uv_handle_t* h){}
|
|
|
382
|
|
|
383 TEST_IMPL(fork_close_signal_in_child) {
|
|
|
384 uv_loop_t loop;
|
|
|
385 uv_signal_t signal_handle;
|
|
|
386 pid_t child_pid;
|
|
|
387
|
|
|
388 ASSERT_OK(uv_loop_init(&loop));
|
|
|
389 ASSERT_OK(uv_signal_init(&loop, &signal_handle));
|
|
|
390 ASSERT_OK(uv_signal_start(&signal_handle, &fork_signal_cb, SIGHUP));
|
|
|
391
|
|
|
392 ASSERT_OK(kill(getpid(), SIGHUP));
|
|
|
393 child_pid = fork();
|
|
|
394 ASSERT_NE(child_pid, -1);
|
|
|
395 ASSERT_OK(fork_signal_cb_called);
|
|
|
396
|
|
|
397 if (!child_pid) {
|
|
|
398 uv_loop_fork(&loop);
|
|
|
399 uv_close((uv_handle_t*)&signal_handle, &empty_close_cb);
|
|
|
400 uv_run(&loop, UV_RUN_DEFAULT);
|
|
|
401 /* Child doesn't receive the signal */
|
|
|
402 ASSERT_OK(fork_signal_cb_called);
|
|
|
403 } else {
|
|
|
404 /* Parent. Runing once to receive the signal */
|
|
|
405 uv_run(&loop, UV_RUN_ONCE);
|
|
|
406 ASSERT_EQ(SIGHUP, fork_signal_cb_called);
|
|
|
407
|
|
|
408 /* loop should stop after closing the only handle */
|
|
|
409 uv_close((uv_handle_t*)&signal_handle, &empty_close_cb);
|
|
|
410 ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT));
|
|
|
411
|
|
|
412 assert_wait_child(child_pid);
|
|
|
413 }
|
|
|
414
|
|
|
415 MAKE_VALGRIND_HAPPY(&loop);
|
|
|
416 return 0;
|
|
|
417 }
|
|
|
418
|
|
|
419
|
|
|
420 static void create_file(const char* name) {
|
|
|
421 int r;
|
|
|
422 uv_file file;
|
|
|
423 uv_fs_t req;
|
|
|
424
|
|
|
425 r = uv_fs_open(NULL, &req, name, O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR, NULL);
|
|
|
426 ASSERT_GE(r, 0);
|
|
|
427 file = r;
|
|
|
428 uv_fs_req_cleanup(&req);
|
|
|
429 r = uv_fs_close(NULL, &req, file, NULL);
|
|
|
430 ASSERT_OK(r);
|
|
|
431 uv_fs_req_cleanup(&req);
|
|
|
432 }
|
|
|
433
|
|
|
434
|
|
|
435 static void touch_file(const char* name) {
|
|
|
436 int r;
|
|
|
437 uv_file file;
|
|
|
438 uv_fs_t req;
|
|
|
439 uv_buf_t buf;
|
|
|
440
|
|
|
441 r = uv_fs_open(NULL, &req, name, O_RDWR, 0, NULL);
|
|
|
442 ASSERT_GE(r, 0);
|
|
|
443 file = r;
|
|
|
444 uv_fs_req_cleanup(&req);
|
|
|
445
|
|
|
446 buf = uv_buf_init("foo", 4);
|
|
|
447 r = uv_fs_write(NULL, &req, file, &buf, 1, -1, NULL);
|
|
|
448 ASSERT_GE(r, 0);
|
|
|
449 uv_fs_req_cleanup(&req);
|
|
|
450
|
|
|
451 r = uv_fs_close(NULL, &req, file, NULL);
|
|
|
452 ASSERT_OK(r);
|
|
|
453 uv_fs_req_cleanup(&req);
|
|
|
454 }
|
|
|
455
|
|
|
456
|
|
|
457 static int timer_cb_touch_called;
|
|
|
458
|
|
|
459 static void timer_cb_touch(uv_timer_t* timer) {
|
|
|
460 uv_close((uv_handle_t*)timer, NULL);
|
|
|
461 touch_file("watch_file");
|
|
|
462 timer_cb_touch_called++;
|
|
|
463 }
|
|
|
464
|
|
|
465
|
|
|
466 static int fs_event_cb_called;
|
|
|
467
|
|
|
468 static void fs_event_cb_file_current_dir(uv_fs_event_t* handle,
|
|
|
469 const char* filename,
|
|
|
470 int events,
|
|
|
471 int status) {
|
|
|
472 ASSERT_OK(fs_event_cb_called);
|
|
|
473 ++fs_event_cb_called;
|
|
|
474 ASSERT_OK(status);
|
|
|
475 #if defined(__APPLE__) || defined(__linux__)
|
|
|
476 ASSERT_OK(strcmp(filename, "watch_file"));
|
|
|
477 #else
|
|
|
478 ASSERT(filename == NULL || strcmp(filename, "watch_file") == 0);
|
|
|
479 #endif
|
|
|
480 uv_close((uv_handle_t*)handle, NULL);
|
|
|
481 }
|
|
|
482
|
|
|
483
|
|
|
484 static void assert_watch_file_current_dir(uv_loop_t* const loop, int file_or_dir) {
|
|
|
485 uv_timer_t timer;
|
|
|
486 uv_fs_event_t fs_event;
|
|
|
487 int r;
|
|
|
488
|
|
|
489 /* Setup */
|
|
|
490 remove("watch_file");
|
|
|
491 create_file("watch_file");
|
|
|
492
|
|
|
493 r = uv_fs_event_init(loop, &fs_event);
|
|
|
494 ASSERT_OK(r);
|
|
|
495 /* watching a dir is the only way to get fsevents involved on apple
|
|
|
496 platforms */
|
|
|
497 r = uv_fs_event_start(&fs_event,
|
|
|
498 fs_event_cb_file_current_dir,
|
|
|
499 file_or_dir == 1 ? "." : "watch_file",
|
|
|
500 0);
|
|
|
501 ASSERT_OK(r);
|
|
|
502
|
|
|
503 r = uv_timer_init(loop, &timer);
|
|
|
504 ASSERT_OK(r);
|
|
|
505
|
|
|
506 r = uv_timer_start(&timer, timer_cb_touch, 100, 0);
|
|
|
507 ASSERT_OK(r);
|
|
|
508
|
|
|
509 ASSERT_OK(timer_cb_touch_called);
|
|
|
510 ASSERT_OK(fs_event_cb_called);
|
|
|
511
|
|
|
512 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
513
|
|
|
514 ASSERT_EQ(1, timer_cb_touch_called);
|
|
|
515 ASSERT_EQ(1, fs_event_cb_called);
|
|
|
516
|
|
|
517 /* Cleanup */
|
|
|
518 remove("watch_file");
|
|
|
519 fs_event_cb_called = 0;
|
|
|
520 timer_cb_touch_called = 0;
|
|
|
521 uv_run(loop, UV_RUN_DEFAULT); /* flush pending closes */
|
|
|
522 }
|
|
|
523
|
|
|
524
|
|
|
525 #define FS_TEST_FILE 0
|
|
|
526 #define FS_TEST_DIR 1
|
|
|
527
|
|
|
528 static int _do_fork_fs_events_child(int file_or_dir) {
|
|
|
529 /* basic fsevents work in the child after a fork */
|
|
|
530 pid_t child_pid;
|
|
|
531 uv_loop_t loop;
|
|
|
532
|
|
|
533 /* Watch in the parent, prime the loop and/or threads. */
|
|
|
534 assert_watch_file_current_dir(uv_default_loop(), file_or_dir);
|
|
|
535 #if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH)
|
|
|
536 child_pid = -1;
|
|
|
537 #else
|
|
|
538 child_pid = fork();
|
|
|
539 #endif
|
|
|
540 ASSERT_NE(child_pid, -1);
|
|
|
541
|
|
|
542 if (child_pid != 0) {
|
|
|
543 /* parent */
|
|
|
544 assert_wait_child(child_pid);
|
|
|
545 } else {
|
|
|
546 /* child */
|
|
|
547 /* Ee can watch in a new loop, but dirs only work
|
|
|
548 if we're on linux. */
|
|
|
549 #if defined(__APPLE__)
|
|
|
550 file_or_dir = FS_TEST_FILE;
|
|
|
551 #endif
|
|
|
552 printf("Running child\n");
|
|
|
553 uv_loop_init(&loop);
|
|
|
554 printf("Child first watch\n");
|
|
|
555 assert_watch_file_current_dir(&loop, file_or_dir);
|
|
|
556 ASSERT_OK(uv_loop_close(&loop));
|
|
|
557 printf("Child second watch default loop\n");
|
|
|
558 /* Ee can watch in the default loop. */
|
|
|
559 ASSERT_OK(uv_loop_fork(uv_default_loop()));
|
|
|
560 /* On some platforms (OS X), if we don't update the time now,
|
|
|
561 * the timer cb fires before the event loop enters uv__io_poll,
|
|
|
562 * instead of after, meaning we don't see the change! This may be
|
|
|
563 * a general race.
|
|
|
564 */
|
|
|
565 uv_update_time(uv_default_loop());
|
|
|
566 assert_watch_file_current_dir(uv_default_loop(), file_or_dir);
|
|
|
567
|
|
|
568 /* We can close the parent loop successfully too. This is
|
|
|
569 especially important on Apple platforms where if we're not
|
|
|
570 careful trying to touch the CFRunLoop, even just to shut it
|
|
|
571 down, that we allocated in the FS_TEST_DIR case would crash. */
|
|
|
572 ASSERT_OK(uv_loop_close(uv_default_loop()));
|
|
|
573
|
|
|
574 printf("Exiting child \n");
|
|
|
575 }
|
|
|
576
|
|
|
577 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
578 return 0;
|
|
|
579
|
|
|
580 }
|
|
|
581
|
|
|
582
|
|
|
583 TEST_IMPL(fork_fs_events_child) {
|
|
|
584 #if defined(NO_FS_EVENTS)
|
|
|
585 RETURN_SKIP(NO_FS_EVENTS);
|
|
|
586 #endif
|
|
|
587 return _do_fork_fs_events_child(FS_TEST_FILE);
|
|
|
588 }
|
|
|
589
|
|
|
590
|
|
|
591 TEST_IMPL(fork_fs_events_child_dir) {
|
|
|
592 #if defined(NO_FS_EVENTS)
|
|
|
593 RETURN_SKIP(NO_FS_EVENTS);
|
|
|
594 #endif
|
|
|
595 #if defined(__APPLE__) || defined (__linux__)
|
|
|
596 return _do_fork_fs_events_child(FS_TEST_DIR);
|
|
|
597 #else
|
|
|
598 /* You can't spin up a cfrunloop thread on an apple platform
|
|
|
599 and then fork. See
|
|
|
600 http://objectivistc.tumblr.com/post/16187948939/you-must-exec-a-core-foundation-fork-safety-tale
|
|
|
601 */
|
|
|
602 return 0;
|
|
|
603 #endif
|
|
|
604 }
|
|
|
605
|
|
|
606
|
|
|
607 TEST_IMPL(fork_fs_events_file_parent_child) {
|
|
|
608 #if defined(NO_FS_EVENTS)
|
|
|
609 RETURN_SKIP(NO_FS_EVENTS);
|
|
|
610 #endif
|
|
|
611 #if defined(__sun) || defined(_AIX) || defined(__MVS__)
|
|
|
612 /* It's not possible to implement this without additional
|
|
|
613 * bookkeeping on SunOS. For AIX it is possible, but has to be
|
|
|
614 * written. See https://github.com/libuv/libuv/pull/846#issuecomment-287170420
|
|
|
615 * TODO: On z/OS, we need to open another message queue and subscribe to the
|
|
|
616 * same events as the parent.
|
|
|
617 */
|
|
|
618 return 0;
|
|
|
619 #else
|
|
|
620 /* Establishing a started fs events watcher in the parent should
|
|
|
621 still work in the child. */
|
|
|
622 uv_timer_t timer;
|
|
|
623 uv_fs_event_t fs_event;
|
|
|
624 int r;
|
|
|
625 pid_t child_pid;
|
|
|
626 uv_loop_t* loop;
|
|
|
627
|
|
|
628 loop = uv_default_loop();
|
|
|
629
|
|
|
630 /* Setup */
|
|
|
631 remove("watch_file");
|
|
|
632 create_file("watch_file");
|
|
|
633
|
|
|
634 r = uv_fs_event_init(loop, &fs_event);
|
|
|
635 ASSERT_OK(r);
|
|
|
636 r = uv_fs_event_start(&fs_event,
|
|
|
637 fs_event_cb_file_current_dir,
|
|
|
638 "watch_file",
|
|
|
639 0);
|
|
|
640 ASSERT_OK(r);
|
|
|
641
|
|
|
642 r = uv_timer_init(loop, &timer);
|
|
|
643 ASSERT_OK(r);
|
|
|
644
|
|
|
645 #if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH)
|
|
|
646 child_pid = -1;
|
|
|
647 #else
|
|
|
648 child_pid = fork();
|
|
|
649 #endif
|
|
|
650 ASSERT_NE(child_pid, -1);
|
|
|
651 if (child_pid != 0) {
|
|
|
652 /* parent */
|
|
|
653 assert_wait_child(child_pid);
|
|
|
654 } else {
|
|
|
655 /* child */
|
|
|
656 printf("Running child\n");
|
|
|
657 ASSERT_OK(uv_loop_fork(loop));
|
|
|
658
|
|
|
659 r = uv_timer_start(&timer, timer_cb_touch, 100, 0);
|
|
|
660 ASSERT_OK(r);
|
|
|
661
|
|
|
662 ASSERT_OK(timer_cb_touch_called);
|
|
|
663 ASSERT_OK(fs_event_cb_called);
|
|
|
664 printf("Running loop in child \n");
|
|
|
665 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
666
|
|
|
667 ASSERT_EQ(1, timer_cb_touch_called);
|
|
|
668 ASSERT_EQ(1, fs_event_cb_called);
|
|
|
669
|
|
|
670 /* Cleanup */
|
|
|
671 remove("watch_file");
|
|
|
672 fs_event_cb_called = 0;
|
|
|
673 timer_cb_touch_called = 0;
|
|
|
674 uv_run(loop, UV_RUN_DEFAULT); /* Flush pending closes. */
|
|
|
675 }
|
|
|
676
|
|
|
677
|
|
|
678 MAKE_VALGRIND_HAPPY(loop);
|
|
|
679 return 0;
|
|
|
680 #endif
|
|
|
681 }
|
|
|
682
|
|
|
683
|
|
|
684 static int work_cb_count;
|
|
|
685 static int after_work_cb_count;
|
|
|
686
|
|
|
687
|
|
|
688 static void work_cb(uv_work_t* req) {
|
|
|
689 work_cb_count++;
|
|
|
690 }
|
|
|
691
|
|
|
692
|
|
|
693 static void after_work_cb(uv_work_t* req, int status) {
|
|
|
694 ASSERT_OK(status);
|
|
|
695 after_work_cb_count++;
|
|
|
696 }
|
|
|
697
|
|
|
698
|
|
|
699 static void assert_run_work(uv_loop_t* const loop) {
|
|
|
700 uv_work_t work_req;
|
|
|
701 int r;
|
|
|
702
|
|
|
703 ASSERT_OK(work_cb_count);
|
|
|
704 ASSERT_OK(after_work_cb_count);
|
|
|
705 printf("Queue in %d\n", getpid());
|
|
|
706 r = uv_queue_work(loop, &work_req, work_cb, after_work_cb);
|
|
|
707 ASSERT_OK(r);
|
|
|
708 printf("Running in %d\n", getpid());
|
|
|
709 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
710
|
|
|
711 ASSERT_EQ(1, work_cb_count);
|
|
|
712 ASSERT_EQ(1, after_work_cb_count);
|
|
|
713
|
|
|
714 /* cleanup */
|
|
|
715 work_cb_count = 0;
|
|
|
716 after_work_cb_count = 0;
|
|
|
717 }
|
|
|
718
|
|
|
719
|
|
|
720 #ifndef __MVS__
|
|
|
721 TEST_IMPL(fork_threadpool_queue_work_simple) {
|
|
|
722 /* The threadpool works in a child process. */
|
|
|
723
|
|
|
724 pid_t child_pid;
|
|
|
725 uv_loop_t loop;
|
|
|
726
|
|
|
727 #ifdef __TSAN__
|
|
|
728 RETURN_SKIP("ThreadSanitizer doesn't support multi-threaded fork");
|
|
|
729 #endif
|
|
|
730
|
|
|
731 /* Prime the pool and default loop. */
|
|
|
732 assert_run_work(uv_default_loop());
|
|
|
733
|
|
|
734 #if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH)
|
|
|
735 child_pid = -1;
|
|
|
736 #else
|
|
|
737 child_pid = fork();
|
|
|
738 #endif
|
|
|
739 ASSERT_NE(child_pid, -1);
|
|
|
740
|
|
|
741 if (child_pid != 0) {
|
|
|
742 /* Parent. We can still run work. */
|
|
|
743 assert_run_work(uv_default_loop());
|
|
|
744 assert_wait_child(child_pid);
|
|
|
745 } else {
|
|
|
746 /* Child. We can work in a new loop. */
|
|
|
747 printf("Running child in %d\n", getpid());
|
|
|
748 uv_loop_init(&loop);
|
|
|
749 printf("Child first watch\n");
|
|
|
750 assert_run_work(&loop);
|
|
|
751 uv_loop_close(&loop);
|
|
|
752 printf("Child second watch default loop\n");
|
|
|
753 /* We can work in the default loop. */
|
|
|
754 ASSERT_OK(uv_loop_fork(uv_default_loop()));
|
|
|
755 assert_run_work(uv_default_loop());
|
|
|
756 printf("Exiting child \n");
|
|
|
757 }
|
|
|
758
|
|
|
759
|
|
|
760 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
761 return 0;
|
|
|
762 }
|
|
|
763 #endif /* !__MVS__ */
|
|
|
764
|
|
|
765 #else
|
|
|
766
|
|
|
767 typedef int file_has_no_tests; /* ISO C forbids an empty translation unit. */
|
|
|
768
|
|
|
769 #endif /* !_WIN32 */
|
