nptl/tst-mutex4.c

   1 /* Copyright (C) 2002, 2003, 2004, 2006 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
   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, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <errno.h>
  21 #include <pthread.h>
  22 #include <stdint.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #include <sys/mman.h>
  28 #include <sys/wait.h>
  29
  30
  31 static int
  32 do_test (void)
  33 {
  34   size_t ps = sysconf (_SC_PAGESIZE);
  35   char tmpfname[] = "/tmp/tst-mutex4.XXXXXX";
  36   char data[ps];
  37   void *mem;
  38   int fd;
  39   pthread_mutex_t *m;
  40   pthread_mutexattr_t a;
  41   pid_t pid;
  42   char *p;
  43   int err;
  44   int s;
  45   pthread_barrier_t *b;
  46   pthread_barrierattr_t ba;
  47
  48   fd = mkstemp (tmpfname);
  49   if (fd == -1)
  50     {
  51       printf ("cannot open temporary file: %m\n");
  52       return 1;
  53     }
  54
  55   /* Make sure it is always removed.  */
  56   unlink (tmpfname);
  57
  58   /* Create one page of data.  */
  59   memset (data, '\0', ps);
  60
  61   /* Write the data to the file.  */
  62   if (write (fd, data, ps) != (ssize_t) ps)
  63     {
  64       puts ("short write");
  65       return 1;
  66     }
  67
  68   mem = mmap (NULL, ps, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
  69   if (mem == MAP_FAILED)
  70     {
  71       printf ("mmap failed: %m\n");
  72       return 1;
  73     }
  74
  75   m = (pthread_mutex_t *) (((uintptr_t) mem + __alignof (pthread_mutex_t) - 1)
  76                            & ~(__alignof (pthread_mutex_t) - 1));
  77   b = (pthread_barrier_t *) (((uintptr_t) (m + 1)
  78                               + __alignof (pthread_barrier_t) - 1)
  79                              & ~(__alignof (pthread_barrier_t) - 1));
  80   p = (char *) (b + 1);
  81
  82   if (pthread_mutexattr_init (&a) != 0)
  83     {
  84       puts ("mutexattr_init failed");
  85       return 1;
  86     }
  87
  88   if (pthread_mutexattr_getpshared (&a, &s) != 0)
  89     {
  90       puts ("1st mutexattr_getpshared failed");
  91       return 1;
  92     }
  93
  94   if (s != PTHREAD_PROCESS_PRIVATE)
  95     {
  96       puts ("default pshared value wrong");
  97       return 1;
  98     }
  99
 100   if (pthread_mutexattr_setpshared (&a, PTHREAD_PROCESS_SHARED) != 0)
 101     {
 102       puts ("mutexattr_setpshared failed");
 103       return 1;
 104     }
 105
 106   if (pthread_mutexattr_getpshared (&a, &s) != 0)
 107     {
 108       puts ("2nd mutexattr_getpshared failed");
 109       return 1;
 110     }
 111
 112   if (s != PTHREAD_PROCESS_SHARED)
 113     {
 114       puts ("pshared value after setpshared call wrong");
 115       return 1;
 116     }
 117
 118 #ifdef ENABLE_PI
 119   if (pthread_mutexattr_setprotocol (&a, PTHREAD_PRIO_INHERIT) != 0)
 120     {
 121       puts ("pthread_mutexattr_setprotocol failed");
 122       return 1;
 123     }
 124 #endif
 125
 126   if ((err = pthread_mutex_init (m, &a)) != 0)
 127     {
 128 #ifdef ENABLE_PI
 129       if (err == ENOTSUP)
 130         {
 131           puts ("PI mutexes unsupported");
 132           return 0;
 133         }
 134 #endif
 135       puts ("mutex_init failed");
 136       return 1;
 137     }
 138
 139   if (pthread_mutex_lock (m) != 0)
 140     {
 141       puts ("mutex_lock failed");
 142       return 1;
 143     }
 144
 145   if (pthread_mutexattr_destroy (&a) != 0)
 146     {
 147       puts ("mutexattr_destroy failed");
 148       return 1;
 149     }
 150
 151   if (pthread_barrierattr_init (&ba) != 0)
 152     {
 153       puts ("barrierattr_init failed");
 154       return 1;
 155     }
 156
 157   if (pthread_barrierattr_setpshared (&ba, PTHREAD_PROCESS_SHARED) != 0)
 158     {
 159       puts ("barrierattr_setpshared failed");
 160       return 1;
 161     }
 162
 163   if (pthread_barrier_init (b, &ba, 2) != 0)
 164     {
 165       puts ("barrier_init failed");
 166       return 1;
 167     }
 168
 169   if (pthread_barrierattr_destroy (&ba) != 0)
 170     {
 171       puts ("barrierattr_destroy failed");
 172       return 1;
 173     }
 174
 175   err = pthread_mutex_trylock (m);
 176   if (err == 0)
 177     {
 178       puts ("mutex_trylock succeeded");
 179       return 1;
 180     }
 181   else if (err != EBUSY)
 182     {
 183       puts ("mutex_trylock didn't return EBUSY");
 184       return 1;
 185     }
 186
 187   *p = 0;
 188
 189   if (pthread_mutex_unlock (m) != 0)
 190     {
 191       puts ("parent: 1st mutex_unlock failed");
 192       return 1;
 193     }
 194
 195   puts ("going to fork now");
 196   pid = fork ();
 197   if (pid == -1)
 198     {
 199       puts ("fork failed");
 200       return 1;
 201     }
 202   else if (pid == 0)
 203     {
 204       if (pthread_mutex_lock (m) != 0)
 205         {
 206           puts ("child: mutex_lock failed");
 207           return 1;
 208         }
 209
 210       int e = pthread_barrier_wait (b);
 211       if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
 212         {
 213           puts ("child: barrier_wait failed");
 214           return 1;
 215         }
 216
 217       if ((*p)++ != 0)
 218         {
 219           puts ("child: *p != 0");
 220           return 1;
 221         }
 222
 223       if (pthread_mutex_unlock (m) != 0)
 224         {
 225           puts ("child: mutex_unlock failed");
 226           return 1;
 227         }
 228
 229       puts ("child done");
 230     }
 231   else
 232     {
 233       int e = pthread_barrier_wait (b);
 234       if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
 235         {
 236           puts ("parent: barrier_wait failed");
 237           return 1;
 238         }
 239
 240       if (pthread_mutex_lock (m) != 0)
 241         {
 242           puts ("parent: 2nd mutex_lock failed");
 243           return 1;
 244         }
 245
 246       if (*p != 1)
 247         {
 248           puts ("*p != 1");
 249           return 1;
 250         }
 251
 252       if (pthread_mutex_unlock (m) != 0)
 253         {
 254           puts ("parent: 2nd mutex_unlock failed");
 255           return 1;
 256         }
 257
 258       if (pthread_mutex_destroy (m) != 0)
 259         {
 260           puts ("mutex_destroy failed");
 261           return 1;
 262         }
 263
 264       if (pthread_barrier_destroy (b) != 0)
 265         {
 266           puts ("barrier_destroy failed");
 267           return 1;
 268         }
 269
 270       puts ("parent done");
 271     }
 272
 273   return 0;
 274 }
 275
 276 #define TIMEOUT 4
 277 #define TEST_FUNCTION do_test ()
 278 #include "../test-skeleton.c"