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 | |
78 | static void * |
79 | tf_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 | |
110 | static void * |
111 | tf_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 | |
143 | static void * |
144 | tf_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 | |
180 | static void * |
181 | tf_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 | |
214 | static void * |
215 | tf_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 | |
232 | static void * |
233 | tf_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 | |
250 | static void * |
251 | tf_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 | |
269 | static void * |
270 | tf_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 | |
304 | static void * |
305 | tf_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 | |
339 | static void * |
340 | tf_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 | |
372 | static void * |
373 | tf_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 | |
405 | static void * |
406 | tf_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 | |
442 | static void * |
443 | tf_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 | |
479 | static void * |
480 | tf_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 | |
520 | static void * |
521 | tf_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 | |
544 | static void * |
545 | tf_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 | |
565 | static void * |
566 | tf_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 | |
591 | static void * |
592 | tf_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 | |
625 | static void * |
626 | tf_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 | |
660 | static void * |
661 | tf_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 | |
678 | static void * |
679 | tf_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 | |
726 | static void * |
727 | tf_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 | |
784 | static void * |
785 | tf_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 | |
835 | static void * |
836 | tf_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 | |
883 | static void * |
884 | tf_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 | |
939 | static void * |
940 | tf_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 | |
965 | static void * |
966 | tf_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 | |
993 | static void * |
994 | tf_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 | |
1021 | static void * |
1022 | tf_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 | |
1050 | static void * |
1051 | tf_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 | |
1082 | static void * |
1083 | tf_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 | |
1115 | static void * |
1116 | tf_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 | |
1150 | static void * |
1151 | tf_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 | |
1184 | static void * |
1185 | tf_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 | |
1210 | static void * |
1211 | tf_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 | |
1236 | static void * |
1237 | tf_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 | |
1264 | static void * |
1265 | tf_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 | |
1317 | static void * |
1318 | tf_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 | |
1378 | static void * |
1379 | tf_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 | |
1400 | static void * |
1401 | tf_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 | |
1450 | static void * |
1451 | tf_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 | |
1475 | static void * |
1476 | tf_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 | |
1525 | static void * |
1526 | tf_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 | |
1571 | struct 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 | |