Warning: That file was not part of the compilation database. It may have many parsing errors.

1/* Copyright (C) 2002-2019 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <http://www.gnu.org/licenses/>. */
18
19/* NOTE: this tests functionality beyond POSIX. POSIX does not allow
20 exit to be called more than once. */
21
22#include <stddef.h>
23#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26#include <sys/types.h>
27#include <sys/socket.h>
28#include <sys/un.h>
29#include <sys/ipc.h>
30#include <sys/msg.h>
31#include <unistd.h>
32#include <errno.h>
33#include <limits.h>
34#include <pthread.h>
35#include <fcntl.h>
36#include <termios.h>
37#include <sys/mman.h>
38#include <sys/poll.h>
39#include <sys/wait.h>
40#include <sys/stat.h>
41#include <sys/uio.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 (fname);
89 if (fd == -1)
90 FAIL_EXIT1 ("mkstemp failed: %m");
91 unlink (fname);
92
93 xpthread_barrier_wait (&b2);
94 }
95
96 xpthread_barrier_wait (&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 (fname);
121 if (fd == -1)
122 FAIL_EXIT1 ("mkstemp failed: %m");
123 unlink (fname);
124
125 xpthread_barrier_wait (&b2);
126 }
127
128 xpthread_barrier_wait (&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, iov, 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 (fname);
154 if (fd == -1)
155 FAIL_EXIT1 ("mkstemp failed: %m");
156 unlink (fname);
157
158 xpthread_barrier_wait (&b2);
159 }
160
161 xpthread_barrier_wait (&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 (fname);
191 if (fd == -1)
192 FAIL_EXIT1 ("mkstemp failed: %m");
193 unlink (fname);
194
195 xpthread_barrier_wait (&b2);
196 }
197
198 xpthread_barrier_wait (&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, iov, 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 (&b2);
218
219 if (arg != NULL)
220 xpthread_barrier_wait (&b2);
221
222 pthread_cleanup_push (cl, NULL);
223
224 sleep (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 (&b2);
236
237 if (arg != NULL)
238 xpthread_barrier_wait (&b2);
239
240 pthread_cleanup_push (cl, NULL);
241
242 usleep (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 (&b2);
254
255 if (arg != NULL)
256 xpthread_barrier_wait (&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 (fname);
280 if (fd == -1)
281 FAIL_EXIT1 ("mkstemp failed: %m");
282 unlink (fname);
283
284 xpthread_barrier_wait (&b2);
285 }
286
287 xpthread_barrier_wait (&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 (fd + 1, &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 (fname);
315 if (fd == -1)
316 FAIL_EXIT1 ("mkstemp failed: %m");
317 unlink (fname);
318
319 xpthread_barrier_wait (&b2);
320 }
321
322 xpthread_barrier_wait (&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 (fd + 1, &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 (fname);
350 if (fd == -1)
351 FAIL_EXIT1 ("mkstemp failed: %m");
352 unlink (fname);
353
354 xpthread_barrier_wait (&b2);
355 }
356
357 xpthread_barrier_wait (&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 (rfs, 1, -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 (fname);
383 if (fd == -1)
384 FAIL_EXIT1 ("mkstemp failed: %m");
385 unlink (fname);
386
387 xpthread_barrier_wait (&b2);
388 }
389
390 xpthread_barrier_wait (&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 (10);
417 exit (0);
418 }
419
420 if (arg != NULL)
421 {
422 struct timespec ts = { .tv_sec = 0, .tv_nsec = 100000000 };
423 while (nanosleep (&ts, &ts) != 0)
424 continue;
425
426 xpthread_barrier_wait (&b2);
427 }
428
429 xpthread_barrier_wait (&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 (10);
454 exit (0);
455 }
456
457 if (arg != NULL)
458 {
459 struct timespec ts = { .tv_sec = 0, .tv_nsec = 100000000 };
460 while (nanosleep (&ts, &ts) != 0)
461 continue;
462
463 xpthread_barrier_wait (&b2);
464 }
465
466 xpthread_barrier_wait (&b2);
467
468 int s;
469 pthread_cleanup_push (cl, NULL);
470
471 s = waitpid (-1, NULL, 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 (10);
491 exit (0);
492 }
493
494 if (arg != NULL)
495 {
496 struct timespec ts = { .tv_sec = 0, .tv_nsec = 100000000 };
497 while (nanosleep (&ts, &ts) != 0)
498 continue;
499
500 xpthread_barrier_wait (&b2);
501 }
502
503 xpthread_barrier_wait (&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 (P_PID, pid, &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 (&b2);
524
525 if (arg != NULL)
526 xpthread_barrier_wait (&b2);
527
528 pthread_cleanup_push (cl, NULL);
529
530 sigpause (sigmask (SIGINT));
531
532 pthread_cleanup_pop (0);
533
534 FAIL_EXIT1 ("sigpause returned");
535}
536
537
538static void *
539tf_sigsuspend (void *arg)
540{
541 xpthread_barrier_wait (&b2);
542
543 if (arg != NULL)
544 xpthread_barrier_wait (&b2);
545
546 pthread_cleanup_push (cl, NULL);
547
548 /* Just for fun block all signals. */
549 sigset_t mask;
550 sigfillset (&mask);
551 sigsuspend (&mask);
552
553 pthread_cleanup_pop (0);
554
555 FAIL_EXIT1 ("sigsuspend returned");
556}
557
558
559static void *
560tf_sigwait (void *arg)
561{
562 xpthread_barrier_wait (&b2);
563
564 if (arg != NULL)
565 xpthread_barrier_wait (&b2);
566
567 /* Block SIGUSR1. */
568 sigset_t mask;
569 sigemptyset (&mask);
570 sigaddset (&mask, SIGUSR1);
571 TEST_VERIFY_EXIT (pthread_sigmask (SIG_BLOCK, &mask, NULL) == 0);
572
573 int sig;
574 pthread_cleanup_push (cl, NULL);
575
576 /* Wait for SIGUSR1. */
577 sigwait (&mask, &sig);
578
579 pthread_cleanup_pop (0);
580
581 FAIL_EXIT1 ("sigwait returned with signal %d", sig);
582}
583
584
585static void *
586tf_sigwaitinfo (void *arg)
587{
588 xpthread_barrier_wait (&b2);
589
590 if (arg != NULL)
591 xpthread_barrier_wait (&b2);
592
593 /* Block SIGUSR1. */
594 sigset_t mask;
595 sigemptyset (&mask);
596 sigaddset (&mask, SIGUSR1);
597 TEST_VERIFY_EXIT (pthread_sigmask (SIG_BLOCK, &mask, NULL) == 0);
598
599 siginfo_t info;
600 pthread_cleanup_push (cl, NULL);
601
602 /* Wait for SIGUSR1. */
603 sigwaitinfo (&mask, &info);
604
605 pthread_cleanup_pop (0);
606
607 FAIL_EXIT1 ("sigwaitinfo returned with signal %d", info.si_signo);
608}
609
610
611static void *
612tf_sigtimedwait (void *arg)
613{
614 xpthread_barrier_wait (&b2);
615
616 if (arg != NULL)
617 xpthread_barrier_wait (&b2);
618
619 /* Block SIGUSR1. */
620 sigset_t mask;
621 sigemptyset (&mask);
622 sigaddset (&mask, SIGUSR1);
623 TEST_VERIFY_EXIT (pthread_sigmask (SIG_BLOCK, &mask, NULL) == 0);
624
625 /* Wait for SIGUSR1. */
626 siginfo_t info;
627 struct timespec ts = { .tv_sec = 60, .tv_nsec = 0 };
628 pthread_cleanup_push (cl, NULL);
629
630 sigtimedwait (&mask, &info, &ts);
631
632 pthread_cleanup_pop (0);
633
634 FAIL_EXIT1 ("sigtimedwait returned with signal %d", info.si_signo);
635}
636
637
638static void *
639tf_pause (void *arg)
640{
641 xpthread_barrier_wait (&b2);
642
643 if (arg != NULL)
644 xpthread_barrier_wait (&b2);
645
646 pthread_cleanup_push (cl, NULL);
647
648 pause ();
649
650 pthread_cleanup_pop (0);
651
652 FAIL_EXIT1 ("pause returned");
653}
654
655
656static void *
657tf_accept (void *arg)
658{
659 struct sockaddr_un sun;
660 /* To test a non-blocking accept call we make the call file by using
661 a datagrame socket. */
662 int pf = arg == NULL ? SOCK_STREAM : SOCK_DGRAM;
663
664 tempfd = socket (AF_UNIX, pf, 0);
665 if (tempfd == -1)
666 FAIL_EXIT1 ("socket (AF_UNIX, %s, 0): %m", arg == NULL ? "SOCK_STREAM"
667 : "SOCK_DGRAM");
668
669 int tries = 0;
670 do
671 {
672 TEST_VERIFY_EXIT (tries++ < 10);
673
674 strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-1-XXXXXX");
675 TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
676
677 sun.sun_family = AF_UNIX;
678 }
679 while (bind (tempfd, (struct sockaddr *) &sun,
680 offsetof (struct sockaddr_un, sun_path)
681 + strlen (sun.sun_path) + 1) != 0);
682
683 unlink (sun.sun_path);
684
685 listen (tempfd, 5);
686
687 socklen_t len = sizeof (sun);
688
689 xpthread_barrier_wait (&b2);
690
691 if (arg != NULL)
692 xpthread_barrier_wait (&b2);
693
694 pthread_cleanup_push (cl, NULL);
695
696 accept (tempfd, (struct sockaddr *) &sun, &len);
697
698 pthread_cleanup_pop (0);
699
700 FAIL_EXIT1 ("accept returned");
701}
702
703
704static void *
705tf_send (void *arg)
706{
707 struct sockaddr_un sun;
708
709 tempfd = socket (AF_UNIX, SOCK_STREAM, 0);
710 if (tempfd == -1)
711 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
712
713 int tries = 0;
714 do
715 {
716 TEST_VERIFY_EXIT (tries++ < 10);
717
718 strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-2-XXXXXX");
719 TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
720
721 sun.sun_family = AF_UNIX;
722 }
723 while (bind (tempfd, (struct sockaddr *) &sun,
724 offsetof (struct sockaddr_un, sun_path)
725 + strlen (sun.sun_path) + 1) != 0);
726
727 listen (tempfd, 5);
728
729 tempfd2 = socket (AF_UNIX, SOCK_STREAM, 0);
730 if (tempfd2 == -1)
731 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
732
733 set_socket_buffer (tempfd2);
734
735 if (connect (tempfd2, (struct sockaddr *) &sun, sizeof (sun)) != 0)
736 FAIL_EXIT1 ("connect: %m");
737
738 unlink (sun.sun_path);
739
740 xpthread_barrier_wait (&b2);
741
742 if (arg != NULL)
743 xpthread_barrier_wait (&b2);
744
745 pthread_cleanup_push (cl, NULL);
746
747 char mem[WRITE_BUFFER_SIZE];
748
749 send (tempfd2, mem, arg == NULL ? sizeof (mem) : 1, 0);
750 /* The send can return a value higher than 0 (meaning partial send)
751 due to the SIGCANCEL, but the thread may still be pending
752 cancellation. */
753 pthread_testcancel ();
754
755 pthread_cleanup_pop (0);
756
757 FAIL_EXIT1 ("send returned");
758}
759
760
761static void *
762tf_recv (void *arg)
763{
764 struct sockaddr_un sun;
765
766 tempfd = socket (AF_UNIX, SOCK_STREAM, 0);
767 if (tempfd == -1)
768 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
769
770 int tries = 0;
771 do
772 {
773 TEST_VERIFY_EXIT (tries++ < 10);
774
775 strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-3-XXXXXX");
776 TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
777
778 sun.sun_family = AF_UNIX;
779 }
780 while (bind (tempfd, (struct sockaddr *) &sun,
781 offsetof (struct sockaddr_un, sun_path)
782 + strlen (sun.sun_path) + 1) != 0);
783
784 listen (tempfd, 5);
785
786 tempfd2 = socket (AF_UNIX, SOCK_STREAM, 0);
787 if (tempfd2 == -1)
788 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
789
790 if (connect (tempfd2, (struct sockaddr *) &sun, sizeof (sun)) != 0)
791 FAIL_EXIT1 ("connect: %m");
792
793 unlink (sun.sun_path);
794
795 xpthread_barrier_wait (&b2);
796
797 if (arg != NULL)
798 xpthread_barrier_wait (&b2);
799
800 pthread_cleanup_push (cl, NULL);
801
802 char mem[70];
803
804 recv (tempfd2, mem, arg == NULL ? sizeof (mem) : 0, 0);
805
806 pthread_cleanup_pop (0);
807
808 FAIL_EXIT1 ("recv returned");
809}
810
811
812static void *
813tf_recvfrom (void *arg)
814{
815 struct sockaddr_un sun;
816
817 tempfd = socket (AF_UNIX, SOCK_DGRAM, 0);
818 if (tempfd == -1)
819 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
820
821 int tries = 0;
822 do
823 {
824 TEST_VERIFY_EXIT (tries++ < 10);
825
826 strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-4-XXXXXX");
827 TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
828
829 sun.sun_family = AF_UNIX;
830 }
831 while (bind (tempfd, (struct sockaddr *) &sun,
832 offsetof (struct sockaddr_un, sun_path)
833 + strlen (sun.sun_path) + 1) != 0);
834
835 tempfname = strdup (sun.sun_path);
836
837 tempfd2 = socket (AF_UNIX, SOCK_DGRAM, 0);
838 if (tempfd2 == -1)
839 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
840
841 xpthread_barrier_wait (&b2);
842
843 if (arg != NULL)
844 xpthread_barrier_wait (&b2);
845
846 pthread_cleanup_push (cl, NULL);
847
848 char mem[70];
849 socklen_t len = sizeof (sun);
850
851 recvfrom (tempfd2, mem, arg == NULL ? sizeof (mem) : 0, 0,
852 (struct sockaddr *) &sun, &len);
853
854 pthread_cleanup_pop (0);
855
856 FAIL_EXIT1 ("recvfrom returned");
857}
858
859
860static void *
861tf_recvmsg (void *arg)
862{
863 struct sockaddr_un sun;
864
865 tempfd = socket (AF_UNIX, SOCK_DGRAM, 0);
866 if (tempfd == -1)
867 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
868
869 int tries = 0;
870 do
871 {
872 TEST_VERIFY_EXIT (tries++ < 10);
873
874 strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-5-XXXXXX");
875 TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
876
877 sun.sun_family = AF_UNIX;
878 }
879 while (bind (tempfd, (struct sockaddr *) &sun,
880 offsetof (struct sockaddr_un, sun_path)
881 + strlen (sun.sun_path) + 1) != 0);
882
883 tempfname = strdup (sun.sun_path);
884
885 tempfd2 = socket (AF_UNIX, SOCK_DGRAM, 0);
886 if (tempfd2 == -1)
887 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
888
889 xpthread_barrier_wait (&b2);
890
891 if (arg != NULL)
892 xpthread_barrier_wait (&b2);
893
894 pthread_cleanup_push (cl, NULL);
895
896 char mem[70];
897 struct iovec iov[1];
898 iov[0].iov_base = mem;
899 iov[0].iov_len = arg == NULL ? sizeof (mem) : 0;
900
901 struct msghdr m;
902 m.msg_name = &sun;
903 m.msg_namelen = sizeof (sun);
904 m.msg_iov = iov;
905 m.msg_iovlen = 1;
906 m.msg_control = NULL;
907 m.msg_controllen = 0;
908
909 recvmsg (tempfd2, &m, 0);
910
911 pthread_cleanup_pop (0);
912
913 FAIL_EXIT1 ("recvmsg returned");
914}
915
916static void *
917tf_open (void *arg)
918{
919 if (arg == NULL)
920 {
921 fifofd = mkfifo (fifoname, S_IWUSR | S_IRUSR);
922 if (fifofd == -1)
923 FAIL_EXIT1 ("mkfifo: %m");
924 }
925 else
926 {
927 xpthread_barrier_wait (&b2);
928 }
929
930 xpthread_barrier_wait (&b2);
931
932 pthread_cleanup_push (cl_fifo, NULL);
933
934 open (arg ? "Makefile" : fifoname, O_RDONLY);
935
936 pthread_cleanup_pop (0);
937
938 FAIL_EXIT1 ("open returned");
939}
940
941
942static void *
943tf_close (void *arg)
944{
945 if (arg == NULL)
946 // XXX If somebody can provide a portable test case in which close()
947 // blocks we can enable this test to run in both rounds.
948 abort ();
949
950 char fname[] = "/tmp/tst-cancel-fd-XXXXXX";
951 tempfd = mkstemp (fname);
952 if (tempfd == -1)
953 FAIL_EXIT1 ("mkstemp failed: %m");
954 unlink (fname);
955
956 xpthread_barrier_wait (&b2);
957
958 xpthread_barrier_wait (&b2);
959
960 pthread_cleanup_push (cl, NULL);
961
962 close (tempfd);
963
964 pthread_cleanup_pop (0);
965
966 FAIL_EXIT1 ("close returned");
967}
968
969
970static void *
971tf_pread (void *arg)
972{
973 if (arg == NULL)
974 // XXX If somebody can provide a portable test case in which pread()
975 // blocks we can enable this test to run in both rounds.
976 abort ();
977
978 tempfd = open ("Makefile", O_RDONLY);
979 if (tempfd == -1)
980 FAIL_EXIT1 ("open (\"Makefile\", O_RDONLY): %m");
981
982 xpthread_barrier_wait (&b2);
983
984 xpthread_barrier_wait (&b2);
985
986 pthread_cleanup_push (cl, NULL);
987
988 char mem[10];
989 pread (tempfd, mem, sizeof (mem), 0);
990
991 pthread_cleanup_pop (0);
992
993 FAIL_EXIT1 ("pread returned");
994}
995
996
997static void *
998tf_pwrite (void *arg)
999{
1000 if (arg == NULL)
1001 // XXX If somebody can provide a portable test case in which pwrite()
1002 // blocks we can enable this test to run in both rounds.
1003 abort ();
1004
1005 char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
1006 tempfd = mkstemp (fname);
1007 if (tempfd == -1)
1008 FAIL_EXIT1 ("mkstemp failed: %m");
1009 unlink (fname);
1010
1011 xpthread_barrier_wait (&b2);
1012
1013 xpthread_barrier_wait (&b2);
1014
1015 pthread_cleanup_push (cl, NULL);
1016
1017 char mem[10];
1018 pwrite (tempfd, mem, sizeof (mem), 0);
1019
1020 pthread_cleanup_pop (0);
1021
1022 FAIL_EXIT1 ("pwrite returned");
1023}
1024
1025static void *
1026tf_preadv (void *arg)
1027{
1028 int fd;
1029
1030 if (arg == NULL)
1031 /* XXX If somebody can provide a portable test case in which preadv
1032 blocks we can enable this test to run in both rounds. */
1033 abort ();
1034
1035 char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
1036 tempfd = fd = mkstemp (fname);
1037 if (fd == -1)
1038 FAIL_EXIT1 ("mkstemp failed: %m");
1039 unlink (fname);
1040
1041 xpthread_barrier_wait (&b2);
1042
1043 xpthread_barrier_wait (&b2);
1044
1045 ssize_t s;
1046 pthread_cleanup_push (cl, NULL);
1047
1048 char buf[100];
1049 struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
1050 s = preadv (fd, iov, 1, 0);
1051
1052 pthread_cleanup_pop (0);
1053
1054 FAIL_EXIT1 ("preadv returns with %zd", s);
1055}
1056
1057static void *
1058tf_pwritev (void *arg)
1059{
1060 int fd;
1061
1062 if (arg == NULL)
1063 /* XXX If somebody can provide a portable test case in which pwritev
1064 blocks we can enable this test to run in both rounds. */
1065 abort ();
1066
1067 char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
1068 tempfd = fd = mkstemp (fname);
1069 if (fd == -1)
1070 FAIL_EXIT1 ("mkstemp failed: %m");
1071 unlink (fname);
1072
1073 xpthread_barrier_wait (&b2);
1074
1075 xpthread_barrier_wait (&b2);
1076
1077 ssize_t s;
1078 pthread_cleanup_push (cl, NULL);
1079
1080 char buf[WRITE_BUFFER_SIZE];
1081 memset (buf, '\0', sizeof (buf));
1082 struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
1083 s = pwritev (fd, iov, 1, 0);
1084
1085 pthread_cleanup_pop (0);
1086
1087 FAIL_EXIT1 ("pwritev returns with %zd", s);
1088}
1089
1090static void *
1091tf_pwritev2 (void *arg)
1092{
1093 int fd;
1094
1095 if (arg == NULL)
1096 /* XXX If somebody can provide a portable test case in which pwritev2
1097 blocks we can enable this test to run in both rounds. */
1098 abort ();
1099
1100 errno = 0;
1101
1102 char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
1103 tempfd = fd = mkstemp (fname);
1104 if (fd == -1)
1105 FAIL_EXIT1 ("mkstemp: %m");
1106 unlink (fname);
1107
1108 xpthread_barrier_wait (&b2);
1109
1110 xpthread_barrier_wait (&b2);
1111
1112 ssize_t s;
1113 pthread_cleanup_push (cl, NULL);
1114
1115 char buf[WRITE_BUFFER_SIZE];
1116 memset (buf, '\0', sizeof (buf));
1117 struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
1118 s = pwritev2 (fd, iov, 1, 0, 0);
1119
1120 pthread_cleanup_pop (0);
1121
1122 FAIL_EXIT1 ("pwritev2 returns with %zd", s);
1123}
1124
1125static void *
1126tf_preadv2 (void *arg)
1127{
1128 int fd;
1129
1130 if (arg == NULL)
1131 /* XXX If somebody can provide a portable test case in which preadv2
1132 blocks we can enable this test to run in both rounds. */
1133 abort ();
1134
1135 errno = 0;
1136
1137 char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
1138 tempfd = fd = mkstemp (fname);
1139 if (fd == -1)
1140 FAIL_EXIT1 ("mkstemp failed: %m");
1141 unlink (fname);
1142
1143 xpthread_barrier_wait (&b2);
1144
1145 xpthread_barrier_wait (&b2);
1146
1147 ssize_t s;
1148 pthread_cleanup_push (cl, NULL);
1149
1150 char buf[100];
1151 struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
1152 s = preadv2 (fd, iov, 1, 0, 0);
1153
1154 pthread_cleanup_pop (0);
1155
1156 FAIL_EXIT1 ("preadv2 returns with %zd", s);
1157}
1158
1159static void *
1160tf_fsync (void *arg)
1161{
1162 if (arg == NULL)
1163 // XXX If somebody can provide a portable test case in which fsync()
1164 // blocks we can enable this test to run in both rounds.
1165 abort ();
1166
1167 tempfd = open ("Makefile", O_RDONLY);
1168 if (tempfd == -1)
1169 FAIL_EXIT1 ("open (\"Makefile\", O_RDONLY): %m");
1170
1171 xpthread_barrier_wait (&b2);
1172
1173 xpthread_barrier_wait (&b2);
1174
1175 pthread_cleanup_push (cl, NULL);
1176
1177 fsync (tempfd);
1178
1179 pthread_cleanup_pop (0);
1180
1181 FAIL_EXIT1 ("fsync returned");
1182}
1183
1184
1185static void *
1186tf_fdatasync (void *arg)
1187{
1188 if (arg == NULL)
1189 // XXX If somebody can provide a portable test case in which fdatasync()
1190 // blocks we can enable this test to run in both rounds.
1191 abort ();
1192
1193 tempfd = open ("Makefile", O_RDONLY);
1194 if (tempfd == -1)
1195 FAIL_EXIT1 ("open (\"Makefile\", O_RDONLY): %m");
1196
1197 xpthread_barrier_wait (&b2);
1198
1199 xpthread_barrier_wait (&b2);
1200
1201 pthread_cleanup_push (cl, NULL);
1202
1203 fdatasync (tempfd);
1204
1205 pthread_cleanup_pop (0);
1206
1207 FAIL_EXIT1 ("fdatasync returned");
1208}
1209
1210
1211static void *
1212tf_msync (void *arg)
1213{
1214 if (arg == NULL)
1215 // XXX If somebody can provide a portable test case in which msync()
1216 // blocks we can enable this test to run in both rounds.
1217 abort ();
1218
1219 tempfd = open ("Makefile", O_RDONLY);
1220 if (tempfd == -1)
1221 FAIL_EXIT1 ("open (\"Makefile\", O_RDONLY): %m");
1222
1223 void *p = xmmap (NULL, 10, PROT_READ, MAP_SHARED, tempfd);
1224
1225 xpthread_barrier_wait (&b2);
1226
1227 xpthread_barrier_wait (&b2);
1228
1229 pthread_cleanup_push (cl, NULL);
1230
1231 msync (p, 10, 0);
1232
1233 pthread_cleanup_pop (0);
1234
1235 FAIL_EXIT1 ("msync returned");
1236}
1237
1238
1239static void *
1240tf_sendto (void *arg)
1241{
1242 struct sockaddr_un sun;
1243
1244 tempfd = socket (AF_UNIX, SOCK_STREAM, 0);
1245 if (tempfd == -1)
1246 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
1247
1248 int tries = 0;
1249 do
1250 {
1251 TEST_VERIFY_EXIT (tries++ < 10);
1252
1253 strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-6-XXXXXX");
1254 TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
1255
1256 sun.sun_family = AF_UNIX;
1257 }
1258 while (bind (tempfd, (struct sockaddr *) &sun,
1259 offsetof (struct sockaddr_un, sun_path)
1260 + strlen (sun.sun_path) + 1) != 0);
1261
1262 listen (tempfd, 5);
1263
1264 tempfd2 = socket (AF_UNIX, SOCK_STREAM, 0);
1265 if (tempfd2 == -1)
1266 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
1267
1268 set_socket_buffer (tempfd2);
1269
1270 if (connect (tempfd2, (struct sockaddr *) &sun, sizeof (sun)) != 0)
1271 FAIL_EXIT1 ("connect: %m");
1272
1273 unlink (sun.sun_path);
1274
1275 xpthread_barrier_wait (&b2);
1276
1277 if (arg != NULL)
1278 xpthread_barrier_wait (&b2);
1279
1280 pthread_cleanup_push (cl, NULL);
1281
1282 char mem[WRITE_BUFFER_SIZE];
1283
1284 sendto (tempfd2, mem, arg == NULL ? sizeof (mem) : 1, 0, NULL, 0);
1285
1286 pthread_cleanup_pop (0);
1287
1288 FAIL_EXIT1 ("sendto returned");
1289}
1290
1291
1292static void *
1293tf_sendmsg (void *arg)
1294{
1295 if (arg == NULL)
1296 // XXX If somebody can provide a portable test case in which sendmsg()
1297 // blocks we can enable this test to run in both rounds.
1298 abort ();
1299
1300 struct sockaddr_un sun;
1301
1302 tempfd = socket (AF_UNIX, SOCK_DGRAM, 0);
1303 if (tempfd == -1)
1304 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
1305
1306 int tries = 0;
1307 do
1308 {
1309 TEST_VERIFY_EXIT (tries++ < 10);
1310
1311 strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-7-XXXXXX");
1312 TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
1313
1314 sun.sun_family = AF_UNIX;
1315 }
1316 while (bind (tempfd, (struct sockaddr *) &sun,
1317 offsetof (struct sockaddr_un, sun_path)
1318 + strlen (sun.sun_path) + 1) != 0);
1319 tempfname = strdup (sun.sun_path);
1320
1321 tempfd2 = socket (AF_UNIX, SOCK_DGRAM, 0);
1322 if (tempfd2 == -1)
1323 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
1324
1325 xpthread_barrier_wait (&b2);
1326
1327 xpthread_barrier_wait (&b2);
1328
1329 pthread_cleanup_push (cl, NULL);
1330
1331 char mem[1];
1332 struct iovec iov[1];
1333 iov[0].iov_base = mem;
1334 iov[0].iov_len = 1;
1335
1336 struct msghdr m;
1337 m.msg_name = &sun;
1338 m.msg_namelen = (offsetof (struct sockaddr_un, sun_path)
1339 + strlen (sun.sun_path) + 1);
1340 m.msg_iov = iov;
1341 m.msg_iovlen = 1;
1342 m.msg_control = NULL;
1343 m.msg_controllen = 0;
1344
1345 sendmsg (tempfd2, &m, 0);
1346
1347 pthread_cleanup_pop (0);
1348
1349 FAIL_EXIT1 ("sendmsg returned");
1350}
1351
1352
1353static void *
1354tf_creat (void *arg)
1355{
1356 if (arg == NULL)
1357 // XXX If somebody can provide a portable test case in which sendmsg()
1358 // blocks we can enable this test to run in both rounds.
1359 abort ();
1360
1361 xpthread_barrier_wait (&b2);
1362
1363 xpthread_barrier_wait (&b2);
1364
1365 pthread_cleanup_push (cl, NULL);
1366
1367 creat ("tmp/tst-cancel-4-should-not-exist", 0666);
1368
1369 pthread_cleanup_pop (0);
1370
1371 FAIL_EXIT1 ("creat returned");
1372}
1373
1374
1375static void *
1376tf_connect (void *arg)
1377{
1378 if (arg == NULL)
1379 // XXX If somebody can provide a portable test case in which connect()
1380 // blocks we can enable this test to run in both rounds.
1381 abort ();
1382
1383 struct sockaddr_un sun;
1384
1385 tempfd = socket (AF_UNIX, SOCK_STREAM, 0);
1386 if (tempfd == -1)
1387 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
1388
1389 int tries = 0;
1390 do
1391 {
1392 TEST_VERIFY_EXIT (tries++ < 10);
1393
1394 strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-2-XXXXXX");
1395 TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
1396
1397 sun.sun_family = AF_UNIX;
1398 }
1399 while (bind (tempfd, (struct sockaddr *) &sun,
1400 offsetof (struct sockaddr_un, sun_path)
1401 + strlen (sun.sun_path) + 1) != 0);
1402 tempfname = strdup (sun.sun_path);
1403
1404 listen (tempfd, 5);
1405
1406 tempfd2 = socket (AF_UNIX, SOCK_STREAM, 0);
1407 if (tempfd2 == -1)
1408 FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
1409
1410 xpthread_barrier_wait (&b2);
1411
1412 if (arg != NULL)
1413 xpthread_barrier_wait (&b2);
1414
1415 pthread_cleanup_push (cl, NULL);
1416
1417 connect (tempfd2, (struct sockaddr *) &sun, sizeof (sun));
1418
1419 pthread_cleanup_pop (0);
1420
1421 FAIL_EXIT1 ("connect returned");
1422}
1423
1424
1425static void *
1426tf_tcdrain (void *arg)
1427{
1428 if (arg == NULL)
1429 // XXX If somebody can provide a portable test case in which tcdrain()
1430 // blocks we can enable this test to run in both rounds.
1431 abort ();
1432
1433 xpthread_barrier_wait (&b2);
1434
1435 if (arg != NULL)
1436 xpthread_barrier_wait (&b2);
1437
1438 pthread_cleanup_push (cl, NULL);
1439
1440 /* Regardless of stderr being a terminal, the tcdrain call should be
1441 canceled. */
1442 tcdrain (STDERR_FILENO);
1443
1444 pthread_cleanup_pop (0);
1445
1446 FAIL_EXIT1 ("tcdrain returned");
1447}
1448
1449
1450static void *
1451tf_msgrcv (void *arg)
1452{
1453 tempmsg = msgget (IPC_PRIVATE, 0666 | IPC_CREAT);
1454 if (tempmsg == -1)
1455 FAIL_EXIT1 ("msgget (IPC_PRIVATE, 0666 | IPC_CREAT): %m");
1456
1457 xpthread_barrier_wait (&b2);
1458
1459 if (arg != NULL)
1460 xpthread_barrier_wait (&b2);
1461
1462 ssize_t s;
1463
1464 pthread_cleanup_push (cl, NULL);
1465
1466 struct
1467 {
1468 long int type;
1469 char mem[10];
1470 } m;
1471 int randnr;
1472 /* We need a positive random number. */
1473 do
1474 randnr = random () % 64000;
1475 while (randnr <= 0);
1476 do
1477 {
1478 errno = 0;
1479 s = msgrcv (tempmsg, (struct msgbuf *) &m, 10, randnr, 0);
1480 }
1481 while (errno == EIDRM || errno == EINTR);
1482
1483 pthread_cleanup_pop (0);
1484
1485 msgctl (tempmsg, IPC_RMID, NULL);
1486
1487 FAIL_EXIT1 ("msgrcv returned %zd", s);
1488}
1489
1490
1491static void *
1492tf_msgsnd (void *arg)
1493{
1494 if (arg == NULL)
1495 // XXX If somebody can provide a portable test case in which msgsnd()
1496 // blocks we can enable this test to run in both rounds.
1497 abort ();
1498
1499 tempmsg = msgget (IPC_PRIVATE, 0666 | IPC_CREAT);
1500 if (tempmsg == -1)
1501 FAIL_EXIT1 ("msgget (IPC_PRIVATE, 0666 | IPC_CREAT): %m");
1502
1503 xpthread_barrier_wait (&b2);
1504
1505 xpthread_barrier_wait (&b2);
1506
1507 pthread_cleanup_push (cl, NULL);
1508
1509 struct
1510 {
1511 long int type;
1512 char mem[1];
1513 } m;
1514 /* We need a positive random number. */
1515 do
1516 m.type = random () % 64000;
1517 while (m.type <= 0);
1518 msgsnd (tempmsg, (struct msgbuf *) &m, sizeof (m.mem), 0);
1519
1520 pthread_cleanup_pop (0);
1521
1522 msgctl (tempmsg, IPC_RMID, NULL);
1523
1524 FAIL_EXIT1 ("msgsnd returned");
1525}
1526
1527
1528struct cancel_tests tests[] =
1529{
1530 ADD_TEST (read, 2, 0),
1531 ADD_TEST (readv, 2, 0),
1532 ADD_TEST (select, 2, 0),
1533 ADD_TEST (pselect, 2, 0),
1534 ADD_TEST (poll, 2, 0),
1535 ADD_TEST (ppoll, 2, 0),
1536 ADD_TEST (write, 2, 0),
1537 ADD_TEST (writev, 2, 0),
1538 ADD_TEST (sleep, 2, 0),
1539 ADD_TEST (usleep, 2, 0),
1540 ADD_TEST (nanosleep, 2, 0),
1541 ADD_TEST (wait, 2, 0),
1542 ADD_TEST (waitid, 2, 0),
1543 ADD_TEST (waitpid, 2, 0),
1544 ADD_TEST (sigpause, 2, 0),
1545 ADD_TEST (sigsuspend, 2, 0),
1546 ADD_TEST (sigwait, 2, 0),
1547 ADD_TEST (sigwaitinfo, 2, 0),
1548 ADD_TEST (sigtimedwait, 2, 0),
1549 ADD_TEST (pause, 2, 0),
1550 ADD_TEST (accept, 2, 0),
1551 ADD_TEST (send, 2, 0),
1552 ADD_TEST (recv, 2, 0),
1553 ADD_TEST (recvfrom, 2, 0),
1554 ADD_TEST (recvmsg, 2, 0),
1555 ADD_TEST (preadv, 2, 1),
1556 ADD_TEST (preadv2, 2, 1),
1557 ADD_TEST (pwritev, 2, 1),
1558 ADD_TEST (pwritev2, 2, 1),
1559 ADD_TEST (open, 2, 1),
1560 ADD_TEST (close, 2, 1),
1561 ADD_TEST (pread, 2, 1),
1562 ADD_TEST (pwrite, 2, 1),
1563 ADD_TEST (fsync, 2, 1),
1564 ADD_TEST (fdatasync, 2, 1),
1565 ADD_TEST (msync, 2, 1),
1566 ADD_TEST (sendto, 2, 1),
1567 ADD_TEST (sendmsg, 2, 1),
1568 ADD_TEST (creat, 2, 1),
1569 ADD_TEST (connect, 2, 1),
1570 ADD_TEST (tcdrain, 2, 1),
1571 ADD_TEST (msgrcv, 2, 0),
1572 ADD_TEST (msgsnd, 2, 1),
1573};
1574#define ntest_tf (sizeof (tests) / sizeof (tests[0]))
1575
1576#include "tst-cancel4-common.c"
1577

Warning: That file was not part of the compilation database. It may have many parsing errors.