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