libuv-svace-build

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 */
770