rt/tst-mqueue5.c

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