1/* Copyright (C) 2002-2024 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, see
16 <https://www.gnu.org/licenses/>. */
17
18/* NOTE: this tests functionality beyond POSIX. POSIX does not allow
19 exit to be called more than once. */
20
21#include <stddef.h>
22#include <stdio.h>
23#include <stdlib.h>
24#include <string.h>
25#include <sys/types.h>
26#include <sys/socket.h>
27#include <sys/un.h>
28#include <sys/ipc.h>
29#include <sys/msg.h>
30#include <unistd.h>
31#include <errno.h>
32#include <limits.h>
33#include <pthread.h>
34#include <fcntl.h>
35#include <termios.h>
36#include <sys/mman.h>
37#include <sys/poll.h>
38#include <sys/wait.h>
39#include <sys/stat.h>
40#include <sys/uio.h>
41#include <libc-diag.h>
42
43
44/* Since STREAMS are not supported in the standard Linux kernel and
45 there we don't advertise STREAMS as supported is no need to test
46 the STREAMS related functions. This affects
47 getmsg() getpmsg() putmsg()
48 putpmsg()
49
50 lockf() and fcntl() are tested in tst-cancel16.
51
52 pthread_join() is tested in tst-join5.
53
54 pthread_testcancel()'s only purpose is to allow cancellation. This
55 is tested in several places.
56
57 sem_wait() and sem_timedwait() are checked in tst-cancel1[2345] tests.
58
59 mq_send(), mq_timedsend(), mq_receive() and mq_timedreceive() are checked
60 in tst-mqueue8{,x} tests.
61
62 aio_suspend() is tested in tst-cancel17.
63
64 clock_nanosleep() is tested in tst-cancel18.
65
66 Linux sendmmsg and recvmmsg are checked in tst-cancel4_1.c and
67 tst-cancel4_2.c respectively.
68*/
69
70#include "tst-cancel4-common.h"
71
72
73#ifndef IPC_ADDVAL
74# define IPC_ADDVAL 0
75#endif
76
77
78static void *
79tf_read (void *arg)
80{
81 int fd;
82
83 if (arg == NULL)
84 fd = fds[0];
85 else
86 {
87 char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
88 tempfd = fd = mkstemp (template: fname);
89 if (fd == -1)
90 FAIL_EXIT1 ("mkstemp failed: %m");
91 unlink (name: fname);
92
93 xpthread_barrier_wait (barrier: &b2);
94 }
95
96 xpthread_barrier_wait (barrier: &b2);
97
98 ssize_t s;
99 pthread_cleanup_push (cl, NULL);
100
101 char buf[100];
102 s = read (fd, buf, sizeof (buf));
103
104 pthread_cleanup_pop (0);
105
106 FAIL_EXIT1 ("read returns with %zd", s);
107}
108
109
110static void *
111tf_readv (void *arg)
112{
113 int fd;
114
115 if (arg == NULL)
116 fd = fds[0];
117 else
118 {
119 char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
120 tempfd = fd = mkstemp (template: fname);
121 if (fd == -1)
122 FAIL_EXIT1 ("mkstemp failed: %m");
123 unlink (name: fname);
124
125 xpthread_barrier_wait (barrier: &b2);
126 }
127
128 xpthread_barrier_wait (barrier: &b2);
129
130 ssize_t s;
131 pthread_cleanup_push (cl, NULL);
132
133 char buf[100];
134 struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
135 s = readv (fd: fd, iovec: iov, count: 1);
136
137 pthread_cleanup_pop (0);
138
139 FAIL_EXIT1 ("readv returns with %zd", s);
140}
141
142
143static void *
144tf_write (void *arg)
145{
146 int fd;
147
148 if (arg == NULL)
149 fd = fds[1];
150 else
151 {
152 char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
153 tempfd = fd = mkstemp (template: fname);
154 if (fd == -1)
155 FAIL_EXIT1 ("mkstemp failed: %m");
156 unlink (name: fname);
157
158 xpthread_barrier_wait (barrier: &b2);
159 }
160
161 xpthread_barrier_wait (barrier: &b2);
162
163 ssize_t s;
164 pthread_cleanup_push (cl, NULL);
165
166 char buf[WRITE_BUFFER_SIZE];
167 memset (buf, '\0', sizeof (buf));
168 s = write (fd, buf, sizeof (buf));
169 /* The write can return a value higher than 0 (meaning partial write)
170 due to the SIGCANCEL, but the thread may still be pending
171 cancellation. */
172 pthread_testcancel ();
173
174 pthread_cleanup_pop (0);
175
176 FAIL_EXIT1 ("write returns with %zd", s);
177}
178
179
180static void *
181tf_writev (void *arg)
182{
183 int fd;
184
185 if (arg == NULL)
186 fd = fds[1];
187 else
188 {
189 char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
190 tempfd = fd = mkstemp (template: fname);
191 if (fd == -1)
192 FAIL_EXIT1 ("mkstemp failed: %m");
193 unlink (name: fname);
194
195 xpthread_barrier_wait (barrier: &b2);
196 }
197
198 xpthread_barrier_wait (barrier: &b2);
199
200 ssize_t s;
201 pthread_cleanup_push (cl, NULL);
202
203 char buf[WRITE_BUFFER_SIZE];
204 memset (buf, '\0', sizeof (buf));
205 struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
206 s = writev (fd: fd, iovec: iov, count: 1);
207
208 pthread_cleanup_pop (0);
209
210 FAIL_EXIT1 ("writev returns with %zd", s);
211}
212
213
214static void *
215tf_sleep (void *arg)
216{
217 xpthread_barrier_wait (barrier: &b2);
218
219 if (arg != NULL)
220 xpthread_barrier_wait (barrier: &b2);
221
222 pthread_cleanup_push (cl, NULL);
223
224 sleep (seconds: arg == NULL ? 1000000 : 0);
225
226 pthread_cleanup_pop (0);
227
228 FAIL_EXIT1 ("sleep returns");
229}
230
231
232static void *
233tf_usleep (void *arg)
234{
235 xpthread_barrier_wait (barrier: &b2);
236
237 if (arg != NULL)
238 xpthread_barrier_wait (barrier: &b2);
239
240 pthread_cleanup_push (cl, NULL);
241
242 usleep (useconds: arg == NULL ? (useconds_t) ULONG_MAX : 0);
243
244 pthread_cleanup_pop (0);
245
246 FAIL_EXIT1 ("usleep returns");
247}
248
249
250static void *
251tf_nanosleep (void *arg)
252{
253 xpthread_barrier_wait (barrier: &b2);
254
255 if (arg != NULL)
256 xpthread_barrier_wait (barrier: &b2);
257
258 pthread_cleanup_push (cl, NULL);
259
260 struct timespec ts = { .tv_sec = arg == NULL ? 10000000 : 0, .tv_nsec = 0 };
261 TEMP_FAILURE_RETRY (nanosleep (&ts, &ts));
262
263 pthread_cleanup_pop (0);
264
265 FAIL_EXIT1 ("nanosleep returns");
266}
267
268
269static void *
270tf_select (void *arg)
271{
272 int fd;
273
274 if (arg == NULL)
275 fd = fds[0];
276 else
277 {
278 char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
279 tempfd = fd = mkstemp (template: fname);
280 if (fd == -1)
281 FAIL_EXIT1 ("mkstemp failed: %m");
282 unlink (name: fname);
283
284 xpthread_barrier_wait (barrier: &b2);
285 }
286
287 xpthread_barrier_wait (barrier: &b2);
288
289 fd_set rfs;
290 FD_ZERO (&rfs);
291 FD_SET (fd, &rfs);
292
293 int s;
294 pthread_cleanup_push (cl, NULL);
295
296 s = select (nfds: fd + 1, readfds: &rfs, NULL, NULL, NULL);
297
298 pthread_cleanup_pop (0);
299
300 FAIL_EXIT1 ("select returns with %d: %m", s);
301}
302
303
304static void *
305tf_pselect (void *arg)
306{
307 int fd;
308
309 if (arg == NULL)
310 fd = fds[0];
311 else
312 {
313 char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
314 tempfd = fd = mkstemp (template: fname);
315 if (fd == -1)
316 FAIL_EXIT1 ("mkstemp failed: %m");
317 unlink (name: fname);
318
319 xpthread_barrier_wait (barrier: &b2);
320 }
321
322 xpthread_barrier_wait (barrier: &b2);
323
324 fd_set rfs;
325 FD_ZERO (&rfs);
326 FD_SET (fd, &rfs);
327
328 int s;
329 pthread_cleanup_push (cl, NULL);
330
331 s = pselect (nfds: fd + 1, readfds: &rfs, NULL, NULL, NULL, NULL);
332
333 pthread_cleanup_pop (0);
334
335 FAIL_EXIT1 ("pselect returns with %d: %m", s);
336}
337
338
339static void *
340tf_poll (void *arg)
341{
342 int fd;
343
344 if (arg == NULL)
345 fd = fds[0];
346 else
347 {
348 char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
349 tempfd = fd = mkstemp (template: fname);
350 if (fd == -1)
351 FAIL_EXIT1 ("mkstemp failed: %m");
352 unlink (name: fname);
353
354 xpthread_barrier_wait (barrier: &b2);
355 }
356
357 xpthread_barrier_wait (barrier: &b2);
358
359 struct pollfd rfs[1] = { [0] = { .fd = fd, .events = POLLIN } };
360
361 int s;
362 pthread_cleanup_push (cl, NULL);
363
364 s = poll (fds: rfs, nfds: 1, timeout: -1);
365
366 pthread_cleanup_pop (0);
367
368 FAIL_EXIT1 ("poll returns with %d: %m", s);
369}
370
371
372static void *
373tf_ppoll (void *arg)
374{
375 int fd;
376
377 if (arg == NULL)
378 fd = fds[0];
379 else
380 {
381 char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
382 tempfd = fd = mkstemp (template: fname);
383 if (fd == -1)
384 FAIL_EXIT1 ("mkstemp failed: %m");
385 unlink (name: fname);
386
387 xpthread_barrier_wait (barrier: &b2);
388 }
389
390 xpthread_barrier_wait (barrier: &b2);
391
392 struct pollfd rfs[1] = { [0] = { .fd = fd, .events = POLLIN } };
393
394 int s;
395 pthread_cleanup_push (cl, NULL);
396
397 s = ppoll (rfs, 1, NULL, NULL);
398
399 pthread_cleanup_pop (0);
400
401 FAIL_EXIT1 ("ppoll returns with %d: %m", s);
402}
403
404
405static void *
406tf_wait (void *arg)
407{
408 pid_t pid = fork ();
409 if (pid == -1)
410 FAIL_EXIT1 ("fork: %m");
411
412 if (pid == 0)
413 {
414 /* Make the program disappear after a while. */
415 if (arg == NULL)
416 sleep (seconds: 10);
417 exit (0);
418 }
419
420 if (arg != NULL)
421 {
422 struct timespec ts = { .tv_sec = 0, .tv_nsec = 100000000 };
423 while (nanosleep (requested_time: &ts, remaining: &ts) != 0)
424 continue;
425
426 xpthread_barrier_wait (barrier: &b2);
427 }
428
429 xpthread_barrier_wait (barrier: &b2);
430
431 int s;
432 pthread_cleanup_push (cl, NULL);
433
434 s = wait (NULL);
435
436 pthread_cleanup_pop (0);
437
438 FAIL_EXIT1 ("wait returns with %d: %m", s);
439}
440
441
442static void *
443tf_waitpid (void *arg)
444{
445 pid_t pid = fork ();
446 if (pid == -1)
447 FAIL_EXIT1 ("fork: %m");
448
449 if (pid == 0)
450 {
451 /* Make the program disappear after a while. */
452 if (arg == NULL)
453 sleep (seconds: 10);
454 exit (0);
455 }
456
457 if (arg != NULL)
458 {
459 struct timespec ts = { .tv_sec = 0, .tv_nsec = 100000000 };
460 while (nanosleep (requested_time: &ts, remaining: &ts) != 0)
461 continue;
462
463 xpthread_barrier_wait (barrier: &b2);
464 }
465
466 xpthread_barrier_wait (barrier: &b2);
467
468 int s;
469 pthread_cleanup_push (cl, NULL);
470
471 s = waitpid (pid: -1, NULL, options: 0);
472
473 pthread_cleanup_pop (0);
474
475 FAIL_EXIT1 ("waitpid returns with %d: %m", s);
476}
477
478
479static void *
480tf_waitid (void *arg)
481{
482 pid_t pid = fork ();
483 if (pid == -1)
484 FAIL_EXIT1 ("fork: %m");
485
486 if (pid == 0)
487 {
488 /* Make the program disappear after a while. */
489 if (arg == NULL)
490 sleep (seconds: 10);
491 exit (0);
492 }
493
494 if (arg != NULL)
495 {
496 struct timespec ts = { .tv_sec = 0, .tv_nsec = 100000000 };
497 while (nanosleep (requested_time: &ts, remaining: &ts) != 0)
498 continue;
499
500 xpthread_barrier_wait (barrier: &b2);
501 }
502
503 xpthread_barrier_wait (barrier: &b2);
504
505 int s;
506 pthread_cleanup_push (cl, NULL);
507
508#ifndef WEXITED
509# define WEXITED 0
510#endif
511 siginfo_t si;
512 s = waitid (idtype: P_PID, id: pid, infop: &si, WEXITED);
513
514 pthread_cleanup_pop (0);
515
516 FAIL_EXIT1 ("waitid returns with %d: %m", s);
517}
518
519
520static void *
521tf_sigpause (void *arg)
522{
523 xpthread_barrier_wait (barrier: &b2);
524
525 if (arg != NULL)
526 xpthread_barrier_wait (barrier: &b2);
527
528 pthread_cleanup_push (cl, NULL);
529
530 /* This tests the deprecated sigpause and sigmask functions. The
531 file is compiled with -Wno-errno so that the sigmask deprecation
532 warning is not fatal. */
533 DIAG_PUSH_NEEDS_COMMENT;
534 DIAG_IGNORE_NEEDS_COMMENT (4.9, "-Wdeprecated-declarations");
535 sigpause (sigmask (SIGINT));
536 DIAG_POP_NEEDS_COMMENT;
537
538 pthread_cleanup_pop (0);
539
540 FAIL_EXIT1 ("sigpause returned");
541}
542
543
544static void *
545tf_sigsuspend (void *arg)
546{
547 xpthread_barrier_wait (barrier: &b2);
548
549 if (arg != NULL)
550 xpthread_barrier_wait (barrier: &b2);
551
552 pthread_cleanup_push (cl, NULL);
553
554 /* Just for fun block all signals. */
555 sigset_t mask;
556 sigfillset (&mask);
557 sigsuspend (set: &mask);
558
559 pthread_cleanup_pop (0);
560
561 FAIL_EXIT1 ("sigsuspend returned");
562}
563
564
565static void *
566tf_sigwait (void *arg)
567{
568 xpthread_barrier_wait (barrier: &b2);
569
570 if (arg != NULL)
571 xpthread_barrier_wait (barrier: &b2);
572
573 /* Block SIGUSR1. */
574 sigset_t mask;
575 sigemptyset (&mask);
576 sigaddset (&mask, SIGUSR1);
577 TEST_VERIFY_EXIT (pthread_sigmask (SIG_BLOCK, &mask, NULL) == 0);
578
579 int sig;
580 pthread_cleanup_push (cl, NULL);
581
582 /* Wait for SIGUSR1. */
583 sigwait (set: &mask, sig: &sig);
584
585 pthread_cleanup_pop (0);
586
587 FAIL_EXIT1 ("sigwait returned with signal %d", sig);
588}
589
590
591static void *
592tf_sigwaitinfo (void *arg)
593{
594 xpthread_barrier_wait (barrier: &b2);
595
596 if (arg != NULL)
597 xpthread_barrier_wait (barrier: &b2);
598
599 /* Block SIGUSR1. */
600 sigset_t mask;
601 sigemptyset (&mask);
602 sigaddset (&mask, SIGUSR1);
603 TEST_VERIFY_EXIT (pthread_sigmask (SIG_BLOCK, &mask, NULL) == 0);
604
605 siginfo_t info;
606 pthread_cleanup_push (cl, NULL);
607
608 /* Wait for SIGUSR1. */
609 int ret;
610 ret = sigwaitinfo (set: &mask, info: &info);
611 if (ret == -1 && errno == ENOSYS)
612 {
613 int sig;
614
615 printf (format: "sigwaitinfo not supported\n");
616 sigwait (set: &mask, sig: &sig);
617 }
618
619 pthread_cleanup_pop (0);
620
621 FAIL_EXIT1 ("sigwaitinfo returned with signal %d", info.si_signo);
622}
623
624
625static void *
626tf_sigtimedwait (void *arg)
627{
628 xpthread_barrier_wait (barrier: &b2);
629
630 if (arg != NULL)
631 xpthread_barrier_wait (barrier: &b2);
632
633 /* Block SIGUSR1. */
634 sigset_t mask;
635 sigemptyset (&mask);
636 sigaddset (&mask, SIGUSR1);
637 TEST_VERIFY_EXIT (pthread_sigmask (SIG_BLOCK, &mask, NULL) == 0);
638
639 /* Wait for SIGUSR1. */
640 siginfo_t info;
641 struct timespec ts = { .tv_sec = 60, .tv_nsec = 0 };
642 pthread_cleanup_push (cl, NULL);
643
644 int ret;
645 ret = sigtimedwait (set: &mask, info: &info, timeout: &ts);
646 if (ret == -1 && errno == ENOSYS)
647 {
648 int sig;
649 printf (format: "sigtimedwait not supported\n");
650
651 sigwait (set: &mask, sig: &sig);
652 }
653
654 pthread_cleanup_pop (0);
655
656 FAIL_EXIT1 ("sigtimedwait returned with signal %d", info.si_signo);
657}
658
659
660static void *
661tf_pause (void *arg)
662{
663 xpthread_barrier_wait (barrier: &b2);
664
665 if (arg != NULL)
666 xpthread_barrier_wait (barrier: &b2);
667
668 pthread_cleanup_push (cl, NULL);
669
670 pause ();
671
672 pthread_cleanup_pop (0);
673
674 FAIL_EXIT1 ("pause returned");
675}
676
677
678static void *
679tf_accept (void *arg)
680{
681 struct sockaddr_un sun;
682 /* To test a non-blocking accept call we make the call file by using
683 a datagrame socket. */
684 int pf = arg == NULL ? SOCK_STREAM : SOCK_DGRAM;
685
686 tempfd = socket (AF_UNIX, type: pf, protocol: 0);
687 if (tempfd == -1)
688 FAIL_EXIT1 ("socket (AF_UNIX, %s, 0): %m", arg == NULL ? "SOCK_STREAM"
689 : "SOCK_DGRAM");
690
691 int tries = 0;
692 do
693 {
694 TEST_VERIFY_EXIT (tries++ < 10);
695
696 strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-1-XXXXXX");
697 TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
698
699 sun.sun_family = AF_UNIX;
700 }
701 while (bind (fd: tempfd, addr: (struct sockaddr *) &sun,
702 offsetof (struct sockaddr_un, sun_path)
703 + strlen (sun.sun_path) + 1) != 0);
704
705 unlink (name: sun.sun_path);
706
707 listen (fd: tempfd, n: 5);
708
709 socklen_t len = sizeof (sun);
710
711 xpthread_barrier_wait (barrier: &b2);
712
713 if (arg != NULL)
714 xpthread_barrier_wait (barrier: &b2);
715
716 pthread_cleanup_push (cl, NULL);
717
718 accept (tempfd, (struct sockaddr *) &sun, &len);
719
720 pthread_cleanup_pop (0);
721
722 FAIL_EXIT1 ("accept returned");
723}
724
725
726static void *
727tf_send (void *arg)
728{
729 struct sockaddr_un sun;
730
731 tempfd = socket (AF_UNIX, SOCK_STREAM, protocol: 0);
732 if (tempfd == -1)
733 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
734
735 int tries = 0;
736 do
737 {
738 TEST_VERIFY_EXIT (tries++ < 10);
739
740 strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-2-XXXXXX");
741 TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
742
743 sun.sun_family = AF_UNIX;
744 }
745 while (bind (fd: tempfd, addr: (struct sockaddr *) &sun,
746 offsetof (struct sockaddr_un, sun_path)
747 + strlen (sun.sun_path) + 1) != 0);
748
749 listen (fd: tempfd, n: 5);
750
751 tempfd2 = socket (AF_UNIX, SOCK_STREAM, protocol: 0);
752 if (tempfd2 == -1)
753 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
754
755 if (connect (fd: tempfd2, addr: (struct sockaddr *) &sun, len: sizeof (sun)) != 0)
756 FAIL_EXIT1 ("connect: %m");
757
758 unlink (name: sun.sun_path);
759
760 set_socket_buffer (tempfd2);
761
762 xpthread_barrier_wait (barrier: &b2);
763
764 if (arg != NULL)
765 xpthread_barrier_wait (barrier: &b2);
766
767 pthread_cleanup_push (cl, NULL);
768
769 char mem[WRITE_BUFFER_SIZE];
770
771 size_t s = send (fd: tempfd2, buf: mem, n: arg == NULL ? sizeof (mem) : 1, flags: 0);
772 /* The send can return a value higher than 0 (meaning partial send)
773 due to the SIGCANCEL, but the thread may still be pending
774 cancellation. */
775 pthread_testcancel ();
776 printf(format: "send returned %zd\n", s);
777
778 pthread_cleanup_pop (0);
779
780 FAIL_EXIT1 ("send returned");
781}
782
783
784static void *
785tf_recv (void *arg)
786{
787 struct sockaddr_un sun;
788
789 tempfd = socket (AF_UNIX, SOCK_STREAM, protocol: 0);
790 if (tempfd == -1)
791 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
792
793 int tries = 0;
794 do
795 {
796 TEST_VERIFY_EXIT (tries++ < 10);
797
798 strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-3-XXXXXX");
799 TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
800
801 sun.sun_family = AF_UNIX;
802 }
803 while (bind (fd: tempfd, addr: (struct sockaddr *) &sun,
804 offsetof (struct sockaddr_un, sun_path)
805 + strlen (sun.sun_path) + 1) != 0);
806
807 listen (fd: tempfd, n: 5);
808
809 tempfd2 = socket (AF_UNIX, SOCK_STREAM, protocol: 0);
810 if (tempfd2 == -1)
811 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
812
813 if (connect (fd: tempfd2, addr: (struct sockaddr *) &sun, len: sizeof (sun)) != 0)
814 FAIL_EXIT1 ("connect: %m");
815
816 unlink (name: sun.sun_path);
817
818 xpthread_barrier_wait (barrier: &b2);
819
820 if (arg != NULL)
821 xpthread_barrier_wait (barrier: &b2);
822
823 pthread_cleanup_push (cl, NULL);
824
825 char mem[70];
826
827 recv (fd: tempfd2, buf: mem, n: arg == NULL ? sizeof (mem) : 0, flags: 0);
828
829 pthread_cleanup_pop (0);
830
831 FAIL_EXIT1 ("recv returned");
832}
833
834
835static void *
836tf_recvfrom (void *arg)
837{
838 struct sockaddr_un sun;
839
840 tempfd = socket (AF_UNIX, SOCK_DGRAM, protocol: 0);
841 if (tempfd == -1)
842 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
843
844 int tries = 0;
845 do
846 {
847 TEST_VERIFY_EXIT (tries++ < 10);
848
849 strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-4-XXXXXX");
850 TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
851
852 sun.sun_family = AF_UNIX;
853 }
854 while (bind (fd: tempfd, addr: (struct sockaddr *) &sun,
855 offsetof (struct sockaddr_un, sun_path)
856 + strlen (sun.sun_path) + 1) != 0);
857
858 tempfname = strdup (s: sun.sun_path);
859
860 tempfd2 = socket (AF_UNIX, SOCK_DGRAM, protocol: 0);
861 if (tempfd2 == -1)
862 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
863
864 xpthread_barrier_wait (barrier: &b2);
865
866 if (arg != NULL)
867 xpthread_barrier_wait (barrier: &b2);
868
869 pthread_cleanup_push (cl, NULL);
870
871 char mem[70];
872 socklen_t len = sizeof (sun);
873
874 recvfrom (fd: tempfd2, buf: mem, n: arg == NULL ? sizeof (mem) : 0, flags: 0,
875 addr: (struct sockaddr *) &sun, addr_len: &len);
876
877 pthread_cleanup_pop (0);
878
879 FAIL_EXIT1 ("recvfrom returned");
880}
881
882
883static void *
884tf_recvmsg (void *arg)
885{
886 struct sockaddr_un sun;
887
888 tempfd = socket (AF_UNIX, SOCK_DGRAM, protocol: 0);
889 if (tempfd == -1)
890 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
891
892 int tries = 0;
893 do
894 {
895 TEST_VERIFY_EXIT (tries++ < 10);
896
897 strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-5-XXXXXX");
898 TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
899
900 sun.sun_family = AF_UNIX;
901 }
902 while (bind (fd: tempfd, addr: (struct sockaddr *) &sun,
903 offsetof (struct sockaddr_un, sun_path)
904 + strlen (sun.sun_path) + 1) != 0);
905
906 tempfname = strdup (s: sun.sun_path);
907
908 tempfd2 = socket (AF_UNIX, SOCK_DGRAM, protocol: 0);
909 if (tempfd2 == -1)
910 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
911
912 xpthread_barrier_wait (barrier: &b2);
913
914 if (arg != NULL)
915 xpthread_barrier_wait (barrier: &b2);
916
917 pthread_cleanup_push (cl, NULL);
918
919 char mem[70];
920 struct iovec iov[1];
921 iov[0].iov_base = mem;
922 iov[0].iov_len = arg == NULL ? sizeof (mem) : 0;
923
924 struct msghdr m;
925 m.msg_name = &sun;
926 m.msg_namelen = sizeof (sun);
927 m.msg_iov = iov;
928 m.msg_iovlen = 1;
929 m.msg_control = NULL;
930 m.msg_controllen = 0;
931
932 recvmsg (fd: tempfd2, message: &m, flags: 0);
933
934 pthread_cleanup_pop (0);
935
936 FAIL_EXIT1 ("recvmsg returned");
937}
938
939static void *
940tf_open (void *arg)
941{
942 if (arg == NULL)
943 {
944 fifofd = mkfifo (path: fifoname, S_IWUSR | S_IRUSR);
945 if (fifofd == -1)
946 FAIL_EXIT1 ("mkfifo: %m");
947 }
948 else
949 {
950 xpthread_barrier_wait (barrier: &b2);
951 }
952
953 xpthread_barrier_wait (barrier: &b2);
954
955 pthread_cleanup_push (cl_fifo, NULL);
956
957 open (file: arg ? "Makefile" : fifoname, O_RDONLY);
958
959 pthread_cleanup_pop (0);
960
961 FAIL_EXIT1 ("open returned");
962}
963
964
965static void *
966tf_close (void *arg)
967{
968 if (arg == NULL)
969 // XXX If somebody can provide a portable test case in which close()
970 // blocks we can enable this test to run in both rounds.
971 abort ();
972
973 char fname[] = "/tmp/tst-cancel-fd-XXXXXX";
974 tempfd = mkstemp (template: fname);
975 if (tempfd == -1)
976 FAIL_EXIT1 ("mkstemp failed: %m");
977 unlink (name: fname);
978
979 xpthread_barrier_wait (barrier: &b2);
980
981 xpthread_barrier_wait (barrier: &b2);
982
983 pthread_cleanup_push (cl, NULL);
984
985 close (fd: tempfd);
986
987 pthread_cleanup_pop (0);
988
989 FAIL_EXIT1 ("close returned");
990}
991
992
993static void *
994tf_pread (void *arg)
995{
996 if (arg == NULL)
997 // XXX If somebody can provide a portable test case in which pread()
998 // blocks we can enable this test to run in both rounds.
999 abort ();
1000
1001 tempfd = open (file: "Makefile", O_RDONLY);
1002 if (tempfd == -1)
1003 FAIL_EXIT1 ("open (\"Makefile\", O_RDONLY): %m");
1004
1005 xpthread_barrier_wait (barrier: &b2);
1006
1007 xpthread_barrier_wait (barrier: &b2);
1008
1009 pthread_cleanup_push (cl, NULL);
1010
1011 char mem[10];
1012 if (pread (fd: tempfd, buf: mem, nbytes: sizeof (mem), offset: 0) < 0)
1013 FAIL_EXIT1 ("pread failed: %m");
1014
1015 pthread_cleanup_pop (0);
1016
1017 FAIL_EXIT1 ("pread returned");
1018}
1019
1020
1021static void *
1022tf_pwrite (void *arg)
1023{
1024 if (arg == NULL)
1025 // XXX If somebody can provide a portable test case in which pwrite()
1026 // blocks we can enable this test to run in both rounds.
1027 abort ();
1028
1029 char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
1030 tempfd = mkstemp (template: fname);
1031 if (tempfd == -1)
1032 FAIL_EXIT1 ("mkstemp failed: %m");
1033 unlink (name: fname);
1034
1035 xpthread_barrier_wait (barrier: &b2);
1036
1037 xpthread_barrier_wait (barrier: &b2);
1038
1039 pthread_cleanup_push (cl, NULL);
1040
1041 char mem[10];
1042 if (pwrite (fd: tempfd, buf: mem, n: sizeof (mem), offset: 0) <0)
1043 FAIL_EXIT1 ("pwrite failed: %m");
1044
1045 pthread_cleanup_pop (0);
1046
1047 FAIL_EXIT1 ("pwrite returned");
1048}
1049
1050static void *
1051tf_preadv (void *arg)
1052{
1053 int fd;
1054
1055 if (arg == NULL)
1056 /* XXX If somebody can provide a portable test case in which preadv
1057 blocks we can enable this test to run in both rounds. */
1058 abort ();
1059
1060 char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
1061 tempfd = fd = mkstemp (template: fname);
1062 if (fd == -1)
1063 FAIL_EXIT1 ("mkstemp failed: %m");
1064 unlink (name: fname);
1065
1066 xpthread_barrier_wait (barrier: &b2);
1067
1068 xpthread_barrier_wait (barrier: &b2);
1069
1070 ssize_t s;
1071 pthread_cleanup_push (cl, NULL);
1072
1073 char buf[100];
1074 struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
1075 s = preadv (fd, iov, 1, 0);
1076
1077 pthread_cleanup_pop (0);
1078
1079 FAIL_EXIT1 ("preadv returns with %zd", s);
1080}
1081
1082static void *
1083tf_pwritev (void *arg)
1084{
1085 int fd;
1086
1087 if (arg == NULL)
1088 /* XXX If somebody can provide a portable test case in which pwritev
1089 blocks we can enable this test to run in both rounds. */
1090 abort ();
1091
1092 char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
1093 tempfd = fd = mkstemp (template: fname);
1094 if (fd == -1)
1095 FAIL_EXIT1 ("mkstemp failed: %m");
1096 unlink (name: fname);
1097
1098 xpthread_barrier_wait (barrier: &b2);
1099
1100 xpthread_barrier_wait (barrier: &b2);
1101
1102 ssize_t s;
1103 pthread_cleanup_push (cl, NULL);
1104
1105 char buf[WRITE_BUFFER_SIZE];
1106 memset (buf, '\0', sizeof (buf));
1107 struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
1108 s = pwritev (fd, iov, 1, 0);
1109
1110 pthread_cleanup_pop (0);
1111
1112 FAIL_EXIT1 ("pwritev returns with %zd", s);
1113}
1114
1115static void *
1116tf_pwritev2 (void *arg)
1117{
1118 int fd;
1119
1120 if (arg == NULL)
1121 /* XXX If somebody can provide a portable test case in which pwritev2
1122 blocks we can enable this test to run in both rounds. */
1123 abort ();
1124
1125 errno = 0;
1126
1127 char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
1128 tempfd = fd = mkstemp (template: fname);
1129 if (fd == -1)
1130 FAIL_EXIT1 ("mkstemp: %m");
1131 unlink (name: fname);
1132
1133 xpthread_barrier_wait (barrier: &b2);
1134
1135 xpthread_barrier_wait (barrier: &b2);
1136
1137 ssize_t s;
1138 pthread_cleanup_push (cl, NULL);
1139
1140 char buf[WRITE_BUFFER_SIZE];
1141 memset (buf, '\0', sizeof (buf));
1142 struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
1143 s = pwritev2 (fd: fd, iodev: iov, count: 1, offset: 0, flags: 0);
1144
1145 pthread_cleanup_pop (0);
1146
1147 FAIL_EXIT1 ("pwritev2 returns with %zd", s);
1148}
1149
1150static void *
1151tf_preadv2 (void *arg)
1152{
1153 int fd;
1154
1155 if (arg == NULL)
1156 /* XXX If somebody can provide a portable test case in which preadv2
1157 blocks we can enable this test to run in both rounds. */
1158 abort ();
1159
1160 errno = 0;
1161
1162 char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
1163 tempfd = fd = mkstemp (template: fname);
1164 if (fd == -1)
1165 FAIL_EXIT1 ("mkstemp failed: %m");
1166 unlink (name: fname);
1167
1168 xpthread_barrier_wait (barrier: &b2);
1169
1170 xpthread_barrier_wait (barrier: &b2);
1171
1172 ssize_t s;
1173 pthread_cleanup_push (cl, NULL);
1174
1175 char buf[100];
1176 struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
1177 s = preadv2 (fp: fd, iovec: iov, count: 1, offset: 0, flags: 0);
1178
1179 pthread_cleanup_pop (0);
1180
1181 FAIL_EXIT1 ("preadv2 returns with %zd", s);
1182}
1183
1184static void *
1185tf_fsync (void *arg)
1186{
1187 if (arg == NULL)
1188 // XXX If somebody can provide a portable test case in which fsync()
1189 // blocks we can enable this test to run in both rounds.
1190 abort ();
1191
1192 tempfd = open (file: "Makefile", O_RDONLY);
1193 if (tempfd == -1)
1194 FAIL_EXIT1 ("open (\"Makefile\", O_RDONLY): %m");
1195
1196 xpthread_barrier_wait (barrier: &b2);
1197
1198 xpthread_barrier_wait (barrier: &b2);
1199
1200 pthread_cleanup_push (cl, NULL);
1201
1202 fsync (tempfd);
1203
1204 pthread_cleanup_pop (0);
1205
1206 FAIL_EXIT1 ("fsync returned");
1207}
1208
1209
1210static void *
1211tf_fdatasync (void *arg)
1212{
1213 if (arg == NULL)
1214 // XXX If somebody can provide a portable test case in which fdatasync()
1215 // blocks we can enable this test to run in both rounds.
1216 abort ();
1217
1218 tempfd = open (file: "Makefile", O_RDONLY);
1219 if (tempfd == -1)
1220 FAIL_EXIT1 ("open (\"Makefile\", O_RDONLY): %m");
1221
1222 xpthread_barrier_wait (barrier: &b2);
1223
1224 xpthread_barrier_wait (barrier: &b2);
1225
1226 pthread_cleanup_push (cl, NULL);
1227
1228 fdatasync (tempfd);
1229
1230 pthread_cleanup_pop (0);
1231
1232 FAIL_EXIT1 ("fdatasync returned");
1233}
1234
1235
1236static void *
1237tf_msync (void *arg)
1238{
1239 if (arg == NULL)
1240 // XXX If somebody can provide a portable test case in which msync()
1241 // blocks we can enable this test to run in both rounds.
1242 abort ();
1243
1244 tempfd = open (file: "Makefile", O_RDONLY);
1245 if (tempfd == -1)
1246 FAIL_EXIT1 ("open (\"Makefile\", O_RDONLY): %m");
1247
1248 void *p = xmmap (NULL, length: 10, PROT_READ, MAP_SHARED, fd: tempfd);
1249
1250 xpthread_barrier_wait (barrier: &b2);
1251
1252 xpthread_barrier_wait (barrier: &b2);
1253
1254 pthread_cleanup_push (cl, NULL);
1255
1256 msync (addr: p, len: 10, flags: 0);
1257
1258 pthread_cleanup_pop (0);
1259
1260 FAIL_EXIT1 ("msync returned");
1261}
1262
1263
1264static void *
1265tf_sendto (void *arg)
1266{
1267 struct sockaddr_un sun;
1268
1269 tempfd = socket (AF_UNIX, SOCK_STREAM, protocol: 0);
1270 if (tempfd == -1)
1271 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
1272
1273 int tries = 0;
1274 do
1275 {
1276 TEST_VERIFY_EXIT (tries++ < 10);
1277
1278 strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-6-XXXXXX");
1279 TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
1280
1281 sun.sun_family = AF_UNIX;
1282 }
1283 while (bind (fd: tempfd, addr: (struct sockaddr *) &sun,
1284 offsetof (struct sockaddr_un, sun_path)
1285 + strlen (sun.sun_path) + 1) != 0);
1286
1287 listen (fd: tempfd, n: 5);
1288
1289 tempfd2 = socket (AF_UNIX, SOCK_STREAM, protocol: 0);
1290 if (tempfd2 == -1)
1291 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
1292
1293 if (connect (fd: tempfd2, addr: (struct sockaddr *) &sun, len: sizeof (sun)) != 0)
1294 FAIL_EXIT1 ("connect: %m");
1295
1296 unlink (name: sun.sun_path);
1297
1298 set_socket_buffer (tempfd2);
1299
1300 xpthread_barrier_wait (barrier: &b2);
1301
1302 if (arg != NULL)
1303 xpthread_barrier_wait (barrier: &b2);
1304
1305 pthread_cleanup_push (cl, NULL);
1306
1307 char mem[WRITE_BUFFER_SIZE];
1308
1309 sendto (fd: tempfd2, buf: mem, n: arg == NULL ? sizeof (mem) : 1, flags: 0, NULL, addr_len: 0);
1310
1311 pthread_cleanup_pop (0);
1312
1313 FAIL_EXIT1 ("sendto returned");
1314}
1315
1316
1317static void *
1318tf_sendmsg (void *arg)
1319{
1320 if (arg == NULL)
1321 // XXX If somebody can provide a portable test case in which sendmsg()
1322 // blocks we can enable this test to run in both rounds.
1323 abort ();
1324
1325 struct sockaddr_un sun;
1326
1327 tempfd = socket (AF_UNIX, SOCK_DGRAM, protocol: 0);
1328 if (tempfd == -1)
1329 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
1330
1331 int tries = 0;
1332 do
1333 {
1334 TEST_VERIFY_EXIT (tries++ < 10);
1335
1336 strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-7-XXXXXX");
1337 TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
1338
1339 sun.sun_family = AF_UNIX;
1340 }
1341 while (bind (fd: tempfd, addr: (struct sockaddr *) &sun,
1342 offsetof (struct sockaddr_un, sun_path)
1343 + strlen (sun.sun_path) + 1) != 0);
1344 tempfname = strdup (s: sun.sun_path);
1345
1346 tempfd2 = socket (AF_UNIX, SOCK_DGRAM, protocol: 0);
1347 if (tempfd2 == -1)
1348 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
1349
1350 xpthread_barrier_wait (barrier: &b2);
1351
1352 xpthread_barrier_wait (barrier: &b2);
1353
1354 pthread_cleanup_push (cl, NULL);
1355
1356 char mem[1];
1357 struct iovec iov[1];
1358 iov[0].iov_base = mem;
1359 iov[0].iov_len = 1;
1360
1361 struct msghdr m;
1362 m.msg_name = &sun;
1363 m.msg_namelen = (offsetof (struct sockaddr_un, sun_path)
1364 + strlen (sun.sun_path) + 1);
1365 m.msg_iov = iov;
1366 m.msg_iovlen = 1;
1367 m.msg_control = NULL;
1368 m.msg_controllen = 0;
1369
1370 sendmsg (fd: tempfd2, message: &m, flags: 0);
1371
1372 pthread_cleanup_pop (0);
1373
1374 FAIL_EXIT1 ("sendmsg returned");
1375}
1376
1377
1378static void *
1379tf_creat (void *arg)
1380{
1381 if (arg == NULL)
1382 // XXX If somebody can provide a portable test case in which sendmsg()
1383 // blocks we can enable this test to run in both rounds.
1384 abort ();
1385
1386 xpthread_barrier_wait (barrier: &b2);
1387
1388 xpthread_barrier_wait (barrier: &b2);
1389
1390 pthread_cleanup_push (cl, NULL);
1391
1392 creat (file: "tmp/tst-cancel-4-should-not-exist", mode: 0666);
1393
1394 pthread_cleanup_pop (0);
1395
1396 FAIL_EXIT1 ("creat returned");
1397}
1398
1399
1400static void *
1401tf_connect (void *arg)
1402{
1403 if (arg == NULL)
1404 // XXX If somebody can provide a portable test case in which connect()
1405 // blocks we can enable this test to run in both rounds.
1406 abort ();
1407
1408 struct sockaddr_un sun;
1409
1410 tempfd = socket (AF_UNIX, SOCK_STREAM, protocol: 0);
1411 if (tempfd == -1)
1412 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
1413
1414 int tries = 0;
1415 do
1416 {
1417 TEST_VERIFY_EXIT (tries++ < 10);
1418
1419 strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-2-XXXXXX");
1420 TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
1421
1422 sun.sun_family = AF_UNIX;
1423 }
1424 while (bind (fd: tempfd, addr: (struct sockaddr *) &sun,
1425 offsetof (struct sockaddr_un, sun_path)
1426 + strlen (sun.sun_path) + 1) != 0);
1427 tempfname = strdup (s: sun.sun_path);
1428
1429 listen (fd: tempfd, n: 5);
1430
1431 tempfd2 = socket (AF_UNIX, SOCK_STREAM, protocol: 0);
1432 if (tempfd2 == -1)
1433 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
1434
1435 xpthread_barrier_wait (barrier: &b2);
1436
1437 if (arg != NULL)
1438 xpthread_barrier_wait (barrier: &b2);
1439
1440 pthread_cleanup_push (cl, NULL);
1441
1442 connect (fd: tempfd2, addr: (struct sockaddr *) &sun, len: sizeof (sun));
1443
1444 pthread_cleanup_pop (0);
1445
1446 FAIL_EXIT1 ("connect returned");
1447}
1448
1449
1450static void *
1451tf_tcdrain (void *arg)
1452{
1453 if (arg == NULL)
1454 // XXX If somebody can provide a portable test case in which tcdrain()
1455 // blocks we can enable this test to run in both rounds.
1456 abort ();
1457
1458 xpthread_barrier_wait (barrier: &b2);
1459
1460 if (arg != NULL)
1461 xpthread_barrier_wait (barrier: &b2);
1462
1463 pthread_cleanup_push (cl, NULL);
1464
1465 /* Regardless of stderr being a terminal, the tcdrain call should be
1466 canceled. */
1467 tcdrain (STDERR_FILENO);
1468
1469 pthread_cleanup_pop (0);
1470
1471 FAIL_EXIT1 ("tcdrain returned");
1472}
1473
1474
1475static void *
1476tf_msgrcv (void *arg)
1477{
1478 tempmsg = msgget (IPC_PRIVATE, msgflg: 0666 | IPC_CREAT);
1479 if (tempmsg == -1)
1480 {
1481 if (errno == ENOSYS)
1482 {
1483 printf (format: "msgget not supported\n");
1484 tf_usleep (arg);
1485 pthread_exit (NULL);
1486 }
1487 else
1488 FAIL_EXIT1 ("msgget (IPC_PRIVATE, 0666 | IPC_CREAT): %m");
1489 }
1490
1491 xpthread_barrier_wait (barrier: &b2);
1492
1493 if (arg != NULL)
1494 xpthread_barrier_wait (barrier: &b2);
1495
1496 ssize_t s;
1497
1498 pthread_cleanup_push (cl, NULL);
1499
1500 struct
1501 {
1502 long int type;
1503 char mem[10];
1504 } m;
1505 int randnr;
1506 /* We need a positive random number. */
1507 do
1508 randnr = random () % 64000;
1509 while (randnr <= 0);
1510 do
1511 {
1512 errno = 0;
1513 s = msgrcv (msqid: tempmsg, msgp: (struct msgbuf *) &m, msgsz: 10, msgtyp: randnr, msgflg: 0);
1514 }
1515 while (errno == EIDRM || errno == EINTR);
1516
1517 pthread_cleanup_pop (0);
1518
1519 msgctl (msqid: tempmsg, IPC_RMID, NULL);
1520
1521 FAIL_EXIT1 ("msgrcv returned %zd", s);
1522}
1523
1524
1525static void *
1526tf_msgsnd (void *arg)
1527{
1528 if (arg == NULL)
1529 // XXX If somebody can provide a portable test case in which msgsnd()
1530 // blocks we can enable this test to run in both rounds.
1531 abort ();
1532
1533 tempmsg = msgget (IPC_PRIVATE, msgflg: 0666 | IPC_CREAT);
1534 if (tempmsg == -1)
1535 {
1536 if (errno == ENOSYS)
1537 {
1538 printf (format: "msgget not supported\n");
1539 tf_usleep (arg);
1540 pthread_exit (NULL);
1541 }
1542 else
1543 FAIL_EXIT1 ("msgget (IPC_PRIVATE, 0666 | IPC_CREAT): %m");
1544 }
1545
1546 xpthread_barrier_wait (barrier: &b2);
1547
1548 xpthread_barrier_wait (barrier: &b2);
1549
1550 pthread_cleanup_push (cl, NULL);
1551
1552 struct
1553 {
1554 long int type;
1555 char mem[1];
1556 } m;
1557 /* We need a positive random number. */
1558 do
1559 m.type = random () % 64000;
1560 while (m.type <= 0);
1561 msgsnd (msqid: tempmsg, msgp: (struct msgbuf *) &m, msgsz: sizeof (m.mem), msgflg: 0);
1562
1563 pthread_cleanup_pop (0);
1564
1565 msgctl (msqid: tempmsg, IPC_RMID, NULL);
1566
1567 FAIL_EXIT1 ("msgsnd returned");
1568}
1569
1570
1571struct cancel_tests tests[] =
1572{
1573 ADD_TEST (read, 2, 0),
1574 ADD_TEST (readv, 2, 0),
1575 ADD_TEST (select, 2, 0),
1576 ADD_TEST (pselect, 2, 0),
1577 ADD_TEST (poll, 2, 0),
1578 ADD_TEST (ppoll, 2, 0),
1579 ADD_TEST (write, 2, 0),
1580 ADD_TEST (writev, 2, 0),
1581 ADD_TEST (sleep, 2, 0),
1582 ADD_TEST (usleep, 2, 0),
1583 ADD_TEST (nanosleep, 2, 0),
1584 ADD_TEST (wait, 2, 0),
1585 ADD_TEST (waitid, 2, 0),
1586 ADD_TEST (waitpid, 2, 0),
1587 ADD_TEST (sigpause, 2, 0),
1588 ADD_TEST (sigsuspend, 2, 0),
1589 ADD_TEST (sigwait, 2, 0),
1590 ADD_TEST (sigwaitinfo, 2, 0),
1591 ADD_TEST (sigtimedwait, 2, 0),
1592 ADD_TEST (pause, 2, 0),
1593 ADD_TEST (accept, 2, 0),
1594 ADD_TEST (send, 2, 0),
1595 ADD_TEST (recv, 2, 0),
1596 ADD_TEST (recvfrom, 2, 0),
1597 ADD_TEST (recvmsg, 2, 0),
1598 ADD_TEST (preadv, 2, 1),
1599 ADD_TEST (preadv2, 2, 1),
1600 ADD_TEST (pwritev, 2, 1),
1601 ADD_TEST (pwritev2, 2, 1),
1602 ADD_TEST (open, 2, 1),
1603 ADD_TEST (close, 2, 1),
1604 ADD_TEST (pread, 2, 1),
1605 ADD_TEST (pwrite, 2, 1),
1606 ADD_TEST (fsync, 2, 1),
1607 ADD_TEST (fdatasync, 2, 1),
1608 ADD_TEST (msync, 2, 1),
1609 ADD_TEST (sendto, 2, 1),
1610 ADD_TEST (sendmsg, 2, 1),
1611 ADD_TEST (creat, 2, 1),
1612 ADD_TEST (connect, 2, 1),
1613 ADD_TEST (tcdrain, 2, 1),
1614 ADD_TEST (msgrcv, 2, 0),
1615 ADD_TEST (msgsnd, 2, 1),
1616};
1617#define ntest_tf (sizeof (tests) / sizeof (tests[0]))
1618
1619#include "tst-cancel4-common.c"
1620

source code of glibc/sysdeps/pthread/tst-cancel4.c