nptl/tst-mutex9.c

   1 /* Copyright (C) 2003 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Ulrich Drepper <drepper@redhat.com>, 2003.
   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 <stdio.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <sys/mman.h>
  26 #include <sys/wait.h>
  27
  28
  29 static int
  30 do_test (void)
  31 {
  32 #if ! _POSIX_THREAD_PROCESS_SHARED
  33
  34   puts ("_POSIX_THREAD_PROCESS_SHARED not supported, test skipped");
  35   return 0;
  36
  37 #else
  38
  39   size_t ps = sysconf (_SC_PAGESIZE);
  40   char tmpfname[] = "/tmp/tst-mutex9.XXXXXX";
  41   char data[ps];
  42   void *mem;
  43   int fd;
  44   pthread_mutex_t *m;
  45   pthread_mutexattr_t a;
  46   pid_t pid;
  47   char *p;
  48
  49   fd = mkstemp (tmpfname);
  50   if (fd == -1)
  51     {
  52       printf ("cannot open temporary file: %m\n");
  53       return 1;
  54     }
  55
  56   /* Make sure it is always removed.  */
  57   unlink (tmpfname);
  58
  59   /* Create one page of data.  */
  60   memset (data, '\0', ps);
  61
  62   /* Write the data to the file.  */
  63   if (write (fd, data, ps) != (ssize_t) ps)
  64     {
  65       puts ("short write");
  66       return 1;
  67     }
  68
  69   mem = mmap (NULL, ps, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
  70   if (mem == MAP_FAILED)
  71     {
  72       printf ("mmap failed: %m\n");
  73       return 1;
  74     }
  75
  76   m = (pthread_mutex_t *) (((uintptr_t) mem + __alignof (pthread_mutex_t))
  77                            & ~(__alignof (pthread_mutex_t) - 1));
  78   p = (char *) (m + 1);
  79
  80   if (pthread_mutexattr_init (&a) != 0)
  81     {
  82       puts ("mutexattr_init failed");
  83       return 1;
  84     }
  85
  86   if (pthread_mutexattr_setpshared (&a, PTHREAD_PROCESS_SHARED) != 0)
  87     {
  88       puts ("mutexattr_setpshared failed");
  89       return 1;
  90     }
  91
  92   if (pthread_mutexattr_settype (&a, PTHREAD_MUTEX_RECURSIVE) != 0)
  93     {
  94       puts ("mutexattr_settype failed");
  95       return 1;
  96     }
  97
  98   if (pthread_mutex_init (m, &a) != 0)
  99     {
 100       puts ("mutex_init failed");
 101       return 1;
 102     }
 103
 104   if (pthread_mutex_lock (m) != 0)
 105     {
 106       puts ("mutex_lock failed");
 107       return 1;
 108     }
 109
 110   if (pthread_mutexattr_destroy (&a) != 0)
 111     {
 112       puts ("mutexattr_destroy failed");
 113       return 1;
 114     }
 115
 116   puts ("going to fork now");
 117   pid = fork ();
 118   if (pid == -1)
 119     {
 120       puts ("fork failed");
 121       return 1;
 122     }
 123   else if (pid == 0)
 124     {
 125       if (pthread_mutex_trylock (m) == 0)
 126         {
 127           puts ("child: mutex_trylock succeeded");
 128           exit (1);
 129         }
 130
 131       if (pthread_mutex_unlock (m) == 0)
 132         {
 133           puts ("child: mutex_unlock succeeded");
 134           exit (1);
 135         }
 136
 137       struct timeval tv;
 138       gettimeofday (&tv, NULL);
 139       struct timespec ts;
 140       TIMEVAL_TO_TIMESPEC (&tv, &ts);
 141       ts.tv_nsec += 500000000;
 142       if (ts.tv_nsec >= 1000000000)
 143         {
 144           ++ts.tv_sec;
 145           ts.tv_nsec -= 1000000000;
 146         }
 147
 148       int e = pthread_mutex_timedlock (m, &ts);
 149       if (e == 0)
 150         {
 151           puts ("child: mutex_timedlock succeeded");
 152           exit (1);
 153         }
 154       if (e != ETIMEDOUT)
 155         {
 156           puts ("child: mutex_timedlock didn't time out");
 157           exit (1);
 158         }
 159
 160       alarm (1);
 161
 162       pthread_mutex_lock (m);
 163
 164       puts ("child: mutex_lock returned");
 165
 166       exit (0);
 167     }
 168
 169   sleep (2);
 170
 171   int status;
 172   if (TEMP_FAILURE_RETRY (waitpid (pid, &status, 0)) != pid)
 173     {
 174       puts ("waitpid failed");
 175       return 1;
 176     }
 177   if (! WIFSIGNALED (status))
 178     {
 179       puts ("child not killed by signal");
 180       return 1;
 181     }
 182   if (WTERMSIG (status) != SIGALRM)
 183     {
 184       puts ("child not killed by SIGALRM");
 185       return 1;
 186     }
 187
 188   return 0;
 189 #endif
 190 }
 191
 192 #define TIMEOUT 3
 193 #define TEST_FUNCTION do_test ()
 194 #include "../test-skeleton.c"