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"