rt/tst-mqueue5.c

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