Test POSIX message queues.
[kopensolaris-gnu/glibc.git] / rt / tst-mqueue5.c
1 /* Test mq_notify.
2    Copyright (C) 2004 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Contributed by Jakub Jelinek <jakub@redhat.com>, 2004.
5
6    The GNU C Library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Lesser General Public
8    License as published by the Free Software Foundation; either
9    version 2.1 of the License, or (at your option) any later version.
10
11    The GNU C Library is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    Lesser General Public License for more details.
15
16    You should have received a copy of the GNU Lesser General Public
17    License along with the GNU C Library; if not, write to the Free
18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19    02111-1307 USA.  */
20
21 #include <errno.h>
22 #include <fcntl.h>
23 #include <mqueue.h>
24 #include <limits.h>
25 #include <signal.h>
26 #include <stdint.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <sys/mman.h>
31 #include <sys/time.h>
32 #include <sys/wait.h>
33 #include <time.h>
34 #include <unistd.h>
35 #include "tst-mqueue.h"
36
37 #define TIMEOUT 3
38
39 #if _POSIX_THREADS
40 # include <pthread.h>
41
42 volatile int rtmin_cnt;
43 volatile pid_t rtmin_pid;
44 volatile uid_t rtmin_uid;
45 volatile union sigval rtmin_sigval;
46
47 static void
48 rtmin_handler (int sig, siginfo_t *info, void *ctx)
49 {
50   if (sig != SIGRTMIN)
51     abort ();
52   ++rtmin_cnt;
53   rtmin_pid = info->si_pid;
54   rtmin_uid = info->si_uid;
55   rtmin_sigval = info->si_value;
56 }
57
58 #define mqsend(q) (mqsend) (q, __LINE__)
59 static inline int
60 (mqsend) (mqd_t q, int line)
61 {
62   char c;
63   if (mq_send (q, &c, 1, 1) != 0)
64     {
65       printf ("mq_send on line %d failed with: %m\n", line);
66       return 1;
67     }
68   return 0;
69 }
70
71 #define mqrecv(q) (mqrecv) (q, __LINE__)
72 static inline int
73 (mqrecv) (mqd_t q, int line)
74 {
75   char c;
76   ssize_t rets = TEMP_FAILURE_RETRY (mq_receive (q, &c, 1, NULL));
77   if (rets != 1)
78     {
79       if (rets == -1)
80         printf ("mq_receive on line %d failed with: %m\n", line);
81       else
82         printf ("mq_receive on line %d returned %zd != 1\n",
83                 line, rets);
84       return 1;
85     }
86   return 0;
87 }
88
89 struct thr_data
90 {
91   const char *name;
92   pthread_barrier_t *b3;
93   mqd_t q;
94 };
95
96 static void *
97 thr (void *arg)
98 {
99   pthread_barrier_t *b3 = ((struct thr_data *)arg)->b3;
100   mqd_t q = ((struct thr_data *)arg)->q;
101   const char *name = ((struct thr_data *)arg)->name;
102   int result = 0;
103
104   result |= mqrecv (q);
105
106   (void) pthread_barrier_wait (b3);
107
108   /* Child verifies SIGRTMIN has not been sent.  */
109
110   (void) pthread_barrier_wait (b3);
111
112   /* Parent calls mqsend (q), which should trigger notification.  */
113
114   (void) pthread_barrier_wait (b3);
115
116   if (rtmin_cnt != 2)
117     {
118       puts ("SIGRTMIN signal in child did not arrive");
119       result = 1;
120     }
121   else if (rtmin_pid != getppid ()
122            || rtmin_uid != getuid ()
123            || rtmin_sigval.sival_int != 0xdeadbeef)
124     {
125       printf ("unexpected siginfo_t fields: pid %u (%u), uid %u (%u), si_int %d (%d)\n",
126               rtmin_pid, getppid (), rtmin_uid, getuid (),
127               rtmin_sigval.sival_int, 0xdeadbeef);
128       result = 1;
129     }
130
131   struct sigevent ev;
132   memset (&ev, 0x82, sizeof (ev));
133   ev.sigev_notify = SIGEV_NONE;
134   if (mq_notify (q, &ev) != 0)
135     {
136       printf ("mq_notify in thread (q, { SIGEV_NONE }) failed with: %m\n");
137       result = 1;
138     }
139
140   if (mq_notify (q, NULL) != 0)
141     {
142       printf ("mq_notify in thread (q, NULL) failed with: %m\n");
143       result = 1;
144     }
145
146   result |= mqrecv (q);
147
148   (void) pthread_barrier_wait (b3);
149
150   /* Child calls mq_notify (q, { SIGEV_SIGNAL }).  */
151
152   (void) pthread_barrier_wait (b3);
153
154   if (mq_notify (q, NULL) != 0)
155     {
156       printf ("second mq_notify in thread (q, NULL) failed with: %m\n");
157       result = 1;
158     }
159
160   (void) pthread_barrier_wait (b3);
161
162   /* Parent calls mqsend (q), which should not trigger notification.  */
163
164   (void) pthread_barrier_wait (b3);
165
166   /* Child verifies SIGRTMIN has not been received.  */
167   /* Child calls mq_notify (q, { SIGEV_SIGNAL }).  */
168
169   (void) pthread_barrier_wait (b3);
170
171   mqd_t q4 = mq_open (name, O_RDONLY);
172   if (q4 == (mqd_t) -1)
173     {
174       printf ("mq_open in thread failed with: %m\n");
175       result = 1;
176     }
177
178   if (mq_notify (q4, NULL) != 0)
179     {
180       printf ("mq_notify in thread (q4, NULL) failed with: %m\n");
181       result = 1;
182     }
183
184   if (mq_close (q4) != 0)
185     {
186       printf ("mq_close in thread failed with: %m\n");
187       result = 1;
188     }
189
190   (void) pthread_barrier_wait (b3);
191
192   /* Parent calls mqsend (q), which should not trigger notification.  */
193
194   (void) pthread_barrier_wait (b3);
195
196   /* Child verifies SIGRTMIN has not been received.  */
197   /* Child calls mq_notify (q, { SIGEV_SIGNAL }).  */
198
199   (void) pthread_barrier_wait (b3);
200
201   mqd_t q5 = mq_open (name, O_WRONLY);
202   if (q5 == (mqd_t) -1)
203     {
204       printf ("mq_open O_WRONLY in thread failed with: %m\n");
205       result = 1;
206     }
207
208   if (mq_notify (q5, NULL) != 0)
209     {
210       printf ("mq_notify in thread (q5, NULL) failed with: %m\n");
211       result = 1;
212     }
213
214   if (mq_close (q5) != 0)
215     {
216       printf ("mq_close in thread failed with: %m\n");
217       result = 1;
218     }
219
220   (void) pthread_barrier_wait (b3);
221
222   /* Parent calls mqsend (q), which should not trigger notification.  */
223
224   (void) pthread_barrier_wait (b3);
225
226   /* Child verifies SIGRTMIN has not been received.  */
227
228   return (void *) (long) result;
229 }
230
231 static void
232 do_child (const char *name, pthread_barrier_t *b2, pthread_barrier_t *b3,
233           mqd_t q)
234 {
235   int result = 0;
236
237   struct sigevent ev;
238   memset (&ev, 0x55, sizeof (ev));
239   ev.sigev_notify = SIGEV_SIGNAL;
240   ev.sigev_signo = SIGRTMIN;
241   ev.sigev_value.sival_ptr = &ev;
242   if (mq_notify (q, &ev) == 0)
243     {
244       puts ("first mq_notify in child (q, { SIGEV_SIGNAL }) unexpectedly succeeded");
245       result = 1;
246     }
247   else if (errno != EBUSY)
248     {
249       printf ("first mq_notify in child (q, { SIGEV_SIGNAL }) failed with: %m\n");
250       result = 1;
251     }
252
253   (void) pthread_barrier_wait (b2);
254
255   /* Parent calls mqsend (q), which makes notification available.  */
256
257   (void) pthread_barrier_wait (b2);
258
259   rtmin_cnt = 0;
260
261   if (mq_notify (q, &ev) != 0)
262     {
263       printf ("second mq_notify in child (q, { SIGEV_SIGNAL }) failed with: %m\n");
264       result = 1;
265     }
266
267   if (rtmin_cnt != 0)
268     {
269       puts ("SIGRTMIN signal in child caught too early");
270       result = 1;
271     }
272
273   (void) pthread_barrier_wait (b2);
274
275   /* Parent unsuccessfully attempts to mq_notify.  */
276   /* Parent calls mqsend (q), which makes notification available
277      and triggers a signal in the child.  */
278   /* Parent successfully calls mq_notify SIGEV_SIGNAL.  */
279
280   (void) pthread_barrier_wait (b2);
281
282   if (rtmin_cnt != 1)
283     {
284       puts ("SIGRTMIN signal in child did not arrive");
285       result = 1;
286     }
287   else if (rtmin_pid != getppid ()
288            || rtmin_uid != getuid ()
289            || rtmin_sigval.sival_ptr != &ev)
290     {
291       printf ("unexpected siginfo_t fields: pid %u (%u), uid %u (%u), si_ptr %p (%p)\n",
292               rtmin_pid, getppid (), rtmin_uid, getuid (),
293               rtmin_sigval.sival_ptr, &ev);
294       result = 1;
295     }
296
297   result |= mqsend (q);
298
299   (void) pthread_barrier_wait (b2);
300
301   /* Parent verifies caught SIGRTMIN.  */
302
303   mqd_t q2 = mq_open (name, O_RDWR);
304   if (q2 == (mqd_t) -1)
305     {
306       printf ("mq_open in child failed with: %m\n");
307       result = 1;
308     }
309
310   (void) pthread_barrier_wait (b2);
311
312   /* Parent mq_open's another mqd_t for the same queue (q3).  */
313
314   memset (&ev, 0x11, sizeof (ev));
315   ev.sigev_notify = SIGEV_SIGNAL;
316   ev.sigev_signo = SIGRTMIN;
317   ev.sigev_value.sival_ptr = &ev;
318   if (mq_notify (q2, &ev) != 0)
319     {
320       printf ("mq_notify in child (q2, { SIGEV_SIGNAL }) failed with: %m\n");
321       result = 1;
322     }
323
324   (void) pthread_barrier_wait (b2);
325
326   /* Parent unsuccessfully attempts to mq_notify { SIGEV_NONE } on q.  */
327
328   (void) pthread_barrier_wait (b2);
329
330   if (mq_close (q2) != 0)
331     {
332       printf ("mq_close failed: %m\n");
333       result = 1;
334     }
335
336   (void) pthread_barrier_wait (b2);
337
338   /* Parent successfully calls mq_notify { SIGEV_NONE } on q3.  */
339
340   (void) pthread_barrier_wait (b2);
341
342   memset (&ev, 0xbb, sizeof (ev));
343   ev.sigev_notify = SIGEV_SIGNAL;
344   ev.sigev_signo = SIGRTMIN;
345   ev.sigev_value.sival_ptr = &b2;
346   if (mq_notify (q, &ev) == 0)
347     {
348       puts ("third mq_notify in child (q, { SIGEV_SIGNAL }) unexpectedly succeeded");
349       result = 1;
350     }
351   else if (errno != EBUSY)
352     {
353       printf ("third mq_notify in child (q, { SIGEV_SIGNAL }) failed with: %m\n");
354       result = 1;
355     }
356
357   (void) pthread_barrier_wait (b2);
358
359   /* Parent calls mq_close on q3, which makes the queue available again for
360      notification.  */
361
362   (void) pthread_barrier_wait (b2);
363
364   memset (&ev, 0x13, sizeof (ev));
365   ev.sigev_notify = SIGEV_NONE;
366   if (mq_notify (q, &ev) != 0)
367     {
368       printf ("mq_notify in child (q, { SIGEV_NONE }) failed with: %m\n");
369       result = 1;
370     }
371
372   if (mq_notify (q, NULL) != 0)
373     {
374       printf ("mq_notify in child (q, NULL) failed with: %m\n");
375       result = 1;
376     }
377
378   (void) pthread_barrier_wait (b2);
379
380   struct thr_data thr_data = { .name = name, .b3 = b3, .q = q };
381   pthread_t th;
382   int ret = pthread_create (&th, NULL, thr, &thr_data);
383   if (ret)
384     {
385       errno = ret;
386       printf ("pthread_created failed with: %m\n");
387       result = 1;
388     }
389
390   /* Wait till thr calls mq_receive on the empty queue q and blocks on it.  */
391   sleep (1);
392
393   memset (&ev, 0x5f, sizeof (ev));
394   ev.sigev_notify = SIGEV_SIGNAL;
395   ev.sigev_signo = SIGRTMIN;
396   ev.sigev_value.sival_int = 0xdeadbeef;
397   if (mq_notify (q, &ev) != 0)
398     {
399       printf ("fourth mq_notify in child (q, { SIGEV_SIGNAL }) failed with: %m\n");
400       result = 1;
401     }
402
403   (void) pthread_barrier_wait (b2);
404
405   /* Parent calls mqsend (q), which should wake up mqrecv (q)
406      in the thread but no notification should be sent.  */
407
408   (void) pthread_barrier_wait (b3);
409
410   if (rtmin_cnt != 1)
411     {
412       puts ("SIGRTMIN signal caught while thr was blocked on mq_receive");
413       result = 1;
414     }
415
416   (void) pthread_barrier_wait (b3);
417
418   /* Parent calls mqsend (q), which should trigger notification.  */
419
420   (void) pthread_barrier_wait (b3);
421
422   /* Thread verifies SIGRTMIN has been received.  */
423   /* Thread calls mq_notify (q, { SIGEV_NONE }) to verify notification is now
424      available for registration.  */
425   /* Thread calls mq_notify (q, NULL).  */
426
427   (void) pthread_barrier_wait (b3);
428
429   memset (&ev, 0x6a, sizeof (ev));
430   ev.sigev_notify = SIGEV_SIGNAL;
431   ev.sigev_signo = SIGRTMIN;
432   ev.sigev_value.sival_ptr = do_child;
433   if (mq_notify (q, &ev) != 0)
434     {
435       printf ("fifth mq_notify in child (q, { SIGEV_SIGNAL }) failed with: %m\n");
436       result = 1;
437     }
438
439   (void) pthread_barrier_wait (b3);
440
441   /* Thread calls mq_notify (q, NULL), which should unregister the above
442      notification.  */
443
444   (void) pthread_barrier_wait (b3);
445
446   /* Parent calls mqsend (q), which should not trigger notification.  */
447
448   (void) pthread_barrier_wait (b3);
449
450   if (rtmin_cnt != 2)
451     {
452       puts ("SIGRTMIN signal caught while notification has been disabled");
453       result = 1;
454     }
455
456   memset (&ev, 0x7b, sizeof (ev));
457   ev.sigev_notify = SIGEV_SIGNAL;
458   ev.sigev_signo = SIGRTMIN;
459   ev.sigev_value.sival_ptr = thr;
460   if (mq_notify (q, &ev) != 0)
461     {
462       printf ("sixth mq_notify in child (q, { SIGEV_SIGNAL }) failed with: %m\n");
463       result = 1;
464     }
465
466   (void) pthread_barrier_wait (b3);
467
468   /* Thread opens a new O_RDONLY mqd_t (q4).  */
469   /* Thread calls mq_notify (q4, NULL), which should unregister the above
470      notification.  */
471   /* Thread calls mq_close (q4).  */ 
472
473   (void) pthread_barrier_wait (b3);
474
475   /* Parent calls mqsend (q), which should not trigger notification.  */
476
477   (void) pthread_barrier_wait (b3);
478
479   if (rtmin_cnt != 2)
480     {
481       puts ("SIGRTMIN signal caught while notification has been disabled");
482       result = 1;
483     }
484
485   memset (&ev, 0xe1, sizeof (ev));
486   ev.sigev_notify = SIGEV_SIGNAL;
487   ev.sigev_signo = SIGRTMIN;
488   ev.sigev_value.sival_int = 127;
489   if (mq_notify (q, &ev) != 0)
490     {
491       printf ("seventh mq_notify in child (q, { SIGEV_SIGNAL }) failed with: %m\n");
492       result = 1;
493     }
494
495   (void) pthread_barrier_wait (b3);
496
497   /* Thread opens a new O_WRONLY mqd_t (q5).  */
498   /* Thread calls mq_notify (q5, NULL), which should unregister the above
499      notification.  */
500   /* Thread calls mq_close (q5).  */ 
501
502   (void) pthread_barrier_wait (b3);
503
504   /* Parent calls mqsend (q), which should not trigger notification.  */
505
506   (void) pthread_barrier_wait (b3);
507
508   if (rtmin_cnt != 2)
509     {
510       puts ("SIGRTMIN signal caught while notification has been disabled");
511       result = 1;
512     }
513
514  void *thr_ret;
515   ret = pthread_join (th, &thr_ret);
516   if (ret)
517     {
518       errno = ret;
519       printf ("pthread_join failed: %m\n");
520       result = 1;
521     }
522   else if (thr_ret)
523     result = 1;
524
525   if (mq_close (q) != 0)
526     {
527       printf ("mq_close failed: %m\n");
528       result = 1;
529     }
530
531   exit (result);
532 }
533
534 #define TEST_FUNCTION do_test ()
535 static int
536 do_test (void)
537 {
538   int result = 0;
539
540   char tmpfname[] = "/tmp/tst-mqueue5-barrier.XXXXXX";
541   int fd = mkstemp (tmpfname);
542   if (fd == -1)
543     {
544       printf ("cannot open temporary file: %m\n");
545       return 1;
546     }
547
548   /* Make sure it is always removed.  */
549   unlink (tmpfname);
550
551   /* Create one page of data.  */
552   size_t ps = sysconf (_SC_PAGESIZE);
553   char data[ps];
554   memset (data, '\0', ps);
555
556   /* Write the data to the file.  */
557   if (write (fd, data, ps) != (ssize_t) ps)
558     {
559       puts ("short write");
560       return 1;
561     }
562
563   void *mem = mmap (NULL, ps, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
564   if (mem == MAP_FAILED)
565     {
566       printf ("mmap failed: %m\n");
567       return 1;
568     }
569
570   pthread_barrier_t *b2;
571   b2 = (pthread_barrier_t *) (((uintptr_t) mem + __alignof (pthread_barrier_t))
572                               & ~(__alignof (pthread_barrier_t) - 1));
573
574   pthread_barrier_t *b3;
575   b3 = b2 + 1;
576
577   pthread_barrierattr_t a;
578   if (pthread_barrierattr_init (&a) != 0)
579     {
580       puts ("barrierattr_init failed");
581       return 1;
582     }
583
584   if (pthread_barrierattr_setpshared (&a, PTHREAD_PROCESS_SHARED) != 0)
585     {
586       puts ("barrierattr_setpshared failed, could not test");
587       return 0;
588     }
589
590   if (pthread_barrier_init (b2, &a, 2) != 0)
591     {
592       puts ("barrier_init failed");
593       return 1;
594     }
595
596   if (pthread_barrier_init (b3, &a, 3) != 0)
597     {
598       puts ("barrier_init failed");
599       return 1;
600     }
601
602   if (pthread_barrierattr_destroy (&a) != 0)
603     {
604       puts ("barrierattr_destroy failed");
605       return 1;
606     }
607
608   char name[sizeof "/tst-mqueue5-" + sizeof (pid_t) * 3];
609   snprintf (name, sizeof (name), "/tst-mqueue5-%u", getpid ());
610
611   struct mq_attr attr = { .mq_maxmsg = 1, .mq_msgsize = 1 };
612   mqd_t q = mq_open (name, O_CREAT | O_EXCL | O_RDWR, 0600, &attr);
613
614   if (q == (mqd_t) -1)
615     {
616       printf ("mq_open failed with: %m\n");
617       return result;
618     }
619   else
620     add_temp_mq (name);
621
622   struct sigevent ev;
623   memset (&ev, 0xaa, sizeof (ev));
624   ev.sigev_notify = SIGEV_NONE;
625   if (mq_notify (q, &ev) != 0)
626     {
627       printf ("mq_notify (q, { SIGEV_NONE }) failed with: %m\n");
628       result = 1;
629     }
630
631   if (mq_notify (q, &ev) == 0)
632     {
633       puts ("second mq_notify (q, { SIGEV_NONE }) unexpectedly succeeded");
634       result = 1;
635     }
636   else if (errno != EBUSY)
637     {
638       printf ("second mq_notify (q, { SIGEV_NONE }) failed with: %m\n");
639       result = 1;
640     }
641
642   result |= mqsend (q);
643
644   if (mq_notify (q, &ev) != 0)
645     {
646       printf ("third mq_notify (q, { SIGEV_NONE }) failed with: %m\n");
647       result = 1;
648     }
649
650   result |= mqrecv (q);
651
652   if (mq_notify (q, NULL) != 0)
653     {
654       printf ("mq_notify (q, NULL) failed with: %m\n");
655       result = 1;
656     }
657
658   if (mq_notify (q, NULL) != 0)
659     {
660       /* Implementation-defined behaviour, so don't fail,
661          just inform.  */
662       printf ("second mq_notify (q, NULL) failed with: %m\n");
663     }
664
665   struct sigaction sa = { .sa_sigaction = rtmin_handler,
666                           .sa_flags = SA_SIGINFO };
667   sigemptyset (&sa.sa_mask);
668   sigaction (SIGRTMIN, &sa, NULL);
669
670   memset (&ev, 0x55, sizeof (ev));
671   ev.sigev_notify = SIGEV_SIGNAL;
672   ev.sigev_signo = SIGRTMIN;
673   ev.sigev_value.sival_int = 26;
674   if (mq_notify (q, &ev) != 0)
675     {
676       printf ("mq_notify (q, { SIGEV_SIGNAL }) failed with: %m\n");
677       result = 1;
678     }
679
680   ev.sigev_value.sival_ptr = &ev;
681   if (mq_notify (q, &ev) == 0)
682     {
683       puts ("second mq_notify (q, { SIGEV_SIGNAL }) unexpectedly succeeded");
684       result = 1;
685     }
686   else if (errno != EBUSY)
687     {
688       printf ("second mq_notify (q, { SIGEV_SIGNAL }) failed with: %m\n");
689       result = 1;
690     }
691
692   if (rtmin_cnt != 0)
693     {
694       puts ("SIGRTMIN signal caught too early");
695       result = 1;
696     }
697
698   result |= mqsend (q);
699
700   if (rtmin_cnt != 1)
701     {
702       puts ("SIGRTMIN signal did not arrive");
703       result = 1;
704     }
705   else if (rtmin_pid != getpid ()
706            || rtmin_uid != getuid ()
707            || rtmin_sigval.sival_int != 26)
708     {
709       printf ("unexpected siginfo_t fields: pid %u (%u), uid %u (%u), si_int %d (26)\n",
710               rtmin_pid, getpid (), rtmin_uid, getuid (),
711               rtmin_sigval.sival_int);
712       result = 1;
713     }
714
715   ev.sigev_value.sival_int = 75;
716   if (mq_notify (q, &ev) != 0)
717     {
718       printf ("third mq_notify (q, { SIGEV_SIGNAL }) failed with: %m\n");
719       result = 1;
720     }
721
722   result |= mqrecv (q);
723
724   if (mq_notify (q, NULL) != 0)
725     {
726       printf ("mq_notify (q, NULL) failed with: %m\n");
727       result = 1;
728     }
729
730   memset (&ev, 0x33, sizeof (ev));
731   ev.sigev_notify = SIGEV_NONE;
732   if (mq_notify (q, &ev) != 0)
733     {
734       printf ("fourth mq_notify (q, { SIGEV_NONE }) failed with: %m\n");
735       result = 1;
736     }
737
738   pid_t pid = fork ();
739   if (pid == -1)
740     {
741       printf ("fork () failed: %m\n");
742       mq_unlink (name);
743       return 1;
744     }
745
746   if (pid == 0)
747     do_child (name, b2, b3, q);
748
749   /* Child unsuccessfully attempts to mq_notify.  */
750
751   (void) pthread_barrier_wait (b2);
752
753   result |= mqsend (q);
754
755   (void) pthread_barrier_wait (b2);
756
757   /* Child successfully calls mq_notify SIGEV_SIGNAL now.  */
758
759   result |= mqrecv (q);
760
761   (void) pthread_barrier_wait (b2);
762
763   memset (&ev, 0xbb, sizeof (ev));
764   ev.sigev_notify = SIGEV_SIGNAL;
765   ev.sigev_signo = SIGRTMIN;
766   ev.sigev_value.sival_int = 15;
767   if (mq_notify (q, &ev) == 0)
768     {
769       puts ("fourth mq_notify (q, { SIGEV_SIGNAL }) unexpectedly succeeded");
770       result = 1;
771     }
772   else if (errno != EBUSY)
773     {
774       printf ("fourth mq_notify (q, { SIGEV_SIGNAL }) failed with: %m\n");
775       result = 1;
776     }
777
778   result |= mqsend (q);
779
780   if (mq_notify (q, &ev) != 0)
781     {
782       printf ("fifth mq_notify (q, { SIGEV_SIGNAL }) failed with: %m\n");
783       result = 1;
784     }
785
786   if (rtmin_cnt != 1)
787     {
788       puts ("SIGRTMIN signal caught too early");
789       result = 1;
790     }
791
792   result |= mqrecv (q);
793
794   (void) pthread_barrier_wait (b2);
795
796   /* Child verifies caught SIGRTMIN signal.  */
797   /* Child calls mq_send (q) which triggers SIGRTMIN signal here.  */
798
799   (void) pthread_barrier_wait (b2);
800
801   /* Child mq_open's another mqd_t for the same queue (q2).  */
802
803   if (rtmin_cnt != 2)
804     {
805       puts ("SIGRTMIN signal did not arrive");
806       result = 1;
807     }
808   else if (rtmin_pid != pid
809            || rtmin_uid != getuid ()
810            || rtmin_sigval.sival_int != 15)
811     {
812       printf ("unexpected siginfo_t fields: pid %u (%u), uid %u (%u), si_int %d (15)\n",
813               rtmin_pid, pid, rtmin_uid, getuid (),
814               rtmin_sigval.sival_int);
815       result = 1;
816     }
817
818   result |= mqrecv (q);
819
820   (void) pthread_barrier_wait (b2);
821
822   /* Child successfully calls mq_notify { SIGEV_SIGNAL } on q2.  */
823
824   (void) pthread_barrier_wait (b2);
825
826   memset (&ev, 0xbb, sizeof (ev));
827   ev.sigev_notify = SIGEV_NONE;
828   if (mq_notify (q, &ev) == 0)
829     {
830       puts ("fifth mq_notify (q, { SIGEV_NONE }) unexpectedly succeeded");
831       result = 1;
832     }
833   else if (errno != EBUSY)
834     {
835       printf ("fifth mq_notify (q, { SIGEV_NONE }) failed with: %m\n");
836       result = 1;
837     }
838
839   (void) pthread_barrier_wait (b2);
840
841   /* Child calls mq_close on q2, which makes the queue available again for
842      notification.  */
843
844   mqd_t q3 = mq_open (name, O_RDWR);
845   if (q3 == (mqd_t) -1)
846     {
847       printf ("mq_open q3 in parent failed with: %m\n");
848       result = 1;
849     }
850
851   (void) pthread_barrier_wait (b2);
852
853   memset (&ev, 0x12, sizeof (ev));
854   ev.sigev_notify = SIGEV_NONE;
855   if (mq_notify (q3, &ev) != 0)
856     {
857       printf ("mq_notify (q3, { SIGEV_NONE }) failed with: %m\n");
858       result = 1;
859     }
860
861   (void) pthread_barrier_wait (b2);
862
863   /* Child unsuccessfully attempts to mq_notify { SIGEV_SIGNAL } on q.  */
864
865   (void) pthread_barrier_wait (b2);
866
867   if (mq_close (q3) != 0)
868     {
869       printf ("mq_close failed: %m\n");
870       result = 1;
871     }
872
873   (void) pthread_barrier_wait (b2);
874
875   /* Child successfully calls mq_notify { SIGEV_NONE } on q.  */
876   /* Child successfully calls mq_notify NULL on q.  */
877
878   (void) pthread_barrier_wait (b2);
879
880   /* Child creates new thread.  */
881   /* Thread blocks on mqrecv (q).  */
882   /* Child sleeps for 1sec so that thread has time to reach that point.  */
883   /* Child successfully calls mq_notify { SIGEV_SIGNAL } on q.  */
884
885   (void) pthread_barrier_wait (b2);
886
887   result |= mqsend (q);
888
889   (void) pthread_barrier_wait (b3);
890
891   /* Child verifies SIGRTMIN has not been sent.  */
892
893   (void) pthread_barrier_wait (b3);
894
895   result |= mqsend (q);
896
897   (void) pthread_barrier_wait (b3);
898
899   /* Thread verifies SIGRTMIN has been caught.  */
900   /* Thread calls mq_notify (q, { SIGEV_NONE }) to verify notification is now
901      available for registration.  */
902   /* Thread calls mq_notify (q, NULL).  */
903
904   (void) pthread_barrier_wait (b3);
905
906   /* Child calls mq_notify (q, { SIGEV_SIGNAL }).  */
907
908   (void) pthread_barrier_wait (b3);
909
910   /* Thread calls mq_notify (q, NULL). */
911
912   (void) pthread_barrier_wait (b3);
913
914   result |= mqsend (q);
915   result |= mqrecv (q);
916
917   (void) pthread_barrier_wait (b3);
918
919   /* Child verifies SIGRTMIN has not been sent.  */
920   /* Child calls mq_notify (q, { SIGEV_SIGNAL }).  */
921
922   (void) pthread_barrier_wait (b3);
923
924   /* Thread opens a new O_RDONLY mqd_t (q4).  */
925   /* Thread calls mq_notify (q4, NULL). */
926   /* Thread calls mq_close (q4).  */
927
928   (void) pthread_barrier_wait (b3);
929
930   result |= mqsend (q);
931   result |= mqrecv (q);
932
933   (void) pthread_barrier_wait (b3);
934
935   /* Child verifies SIGRTMIN has not been sent.  */
936   /* Child calls mq_notify (q, { SIGEV_SIGNAL }).  */
937
938   (void) pthread_barrier_wait (b3);
939
940   /* Thread opens a new O_WRONLY mqd_t (q5).  */
941   /* Thread calls mq_notify (q5, NULL). */
942   /* Thread calls mq_close (q5).  */
943
944   (void) pthread_barrier_wait (b3);
945
946   result |= mqsend (q);
947   result |= mqrecv (q);
948
949   (void) pthread_barrier_wait (b3);
950
951   /* Child verifies SIGRTMIN has not been sent.  */
952
953   int status;
954   if (TEMP_FAILURE_RETRY (waitpid (pid, &status, 0)) != pid)
955     {
956       puts ("waitpid failed");
957       kill (pid, SIGKILL);
958       result = 1;
959     }
960   else if (!WIFEXITED (status) || WEXITSTATUS (status))
961     {
962       printf ("child failed with status %d\n", status);
963       result = 1;
964     }
965
966   if (mq_unlink (name) != 0)
967     {
968       printf ("mq_unlink failed: %m\n");
969       result = 1;
970     }
971
972   if (mq_close (q) != 0)
973     {
974       printf ("mq_close failed: %m\n");
975       result = 1;
976     }
977
978   if (mq_notify (q, NULL) == 0)
979     {
980       puts ("mq_notify on closed mqd_t unexpectedly succeeded");
981       result = 1;
982     }
983   else if (errno != EBADF)
984     {
985       printf ("mq_notify on closed mqd_t did not fail with EBADF: %m\n");
986       result = 1;
987     }
988
989   memset (&ev, 0x55, sizeof (ev));
990   ev.sigev_notify = SIGEV_NONE;
991   if (mq_notify (q, &ev) == 0)
992     {
993       puts ("mq_notify on closed mqd_t unexpectedly succeeded");
994       result = 1;
995     }
996   else if (errno != EBADF)
997     {
998       printf ("mq_notify on closed mqd_t did not fail with EBADF: %m\n");
999       result = 1;
1000     }
1001
1002   return result;
1003 }
1004 #else
1005 # define TEST_FUNCTION 0
1006 #endif
1007
1008 #include "../test-skeleton.c"