nptl/tst-cond25.c

   1 /* Verify that condition variables synchronized by PI mutexes don't hang on
   2    on cancellation.
   3    Copyright (C) 2012 Free Software Foundation, Inc.
   4    This file is part of the GNU C Library.
   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 <pthread.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <errno.h>
  25 #include <sys/types.h>
  26 #include <sys/syscall.h>
  27 #include <unistd.h>
  28 #include <sys/time.h>
  29 #include <time.h>
  30
  31 #define NUM 5
  32 #define ITERS 10000
  33 #define COUNT 100
  34
  35 typedef void *(*thr_func) (void *);
  36
  37 pthread_mutex_t mutex;
  38 pthread_cond_t cond;
  39
  40 void cleanup (void *u)
  41 {
  42   /* pthread_cond_wait should always return with the mutex locked.  */
  43   if (pthread_mutex_unlock (&mutex))
  44     abort ();
  45 }
  46
  47 void *
  48 signaller (void *u)
  49 {
  50   int i, ret = 0;
  51   void *tret = NULL;
  52
  53   for (i = 0; i < ITERS; i++)
  54     {
  55       if ((ret = pthread_mutex_lock (&mutex)) != 0)
  56         {
  57           tret = (void *)1;
  58           printf ("signaller:mutex_lock failed: %s\n", strerror (ret));
  59           goto out;
  60         }
  61       if ((ret = pthread_cond_signal (&cond)) != 0)
  62         {
  63           tret = (void *)1;
  64           printf ("signaller:signal failed: %s\n", strerror (ret));
  65           goto unlock_out;
  66         }
  67       if ((ret = pthread_mutex_unlock (&mutex)) != 0)
  68         {
  69           tret = (void *)1;
  70           printf ("signaller:mutex_unlock failed: %s\n", strerror (ret));
  71           goto out;
  72         }
  73       pthread_testcancel ();
  74     }
  75
  76 out:
  77   return tret;
  78
  79 unlock_out:
  80   if ((ret = pthread_mutex_unlock (&mutex)) != 0)
  81     printf ("signaller:mutex_unlock[2] failed: %s\n", strerror (ret));
  82   goto out;
  83 }
  84
  85 void *
  86 waiter (void *u)
  87 {
  88   int i, ret = 0;
  89   void *tret = NULL;
  90   int seq = (int)u;
  91
  92   for (i = 0; i < ITERS / NUM; i++)
  93     {
  94       if ((ret = pthread_mutex_lock (&mutex)) != 0)
  95         {
  96           tret = (void *)1;
  97           printf ("waiter[%u]:mutex_lock failed: %s\n", seq, strerror (ret));
  98           goto out;
  99         }
 100       pthread_cleanup_push (cleanup, NULL);
 101
 102       if ((ret = pthread_cond_wait (&cond, &mutex)) != 0)
 103         {
 104           tret = (void *)1;
 105           printf ("waiter[%u]:wait failed: %s\n", seq, strerror (ret));
 106           goto unlock_out;
 107         }
 108
 109       if ((ret = pthread_mutex_unlock (&mutex)) != 0)
 110         {
 111           tret = (void *)1;
 112           printf ("waiter[%u]:mutex_unlock failed: %s\n", seq, strerror (ret));
 113           goto out;
 114         }
 115       pthread_cleanup_pop (0);
 116     }
 117
 118 out:
 119   puts ("waiter tests done");
 120   return tret;
 121
 122 unlock_out:
 123   if ((ret = pthread_mutex_unlock (&mutex)) != 0)
 124     printf ("waiter:mutex_unlock[2] failed: %s\n", strerror (ret));
 125   goto out;
 126 }
 127
 128 void *
 129 timed_waiter (void *u)
 130 {
 131   int i, ret;
 132   void *tret = NULL;
 133   int seq = (int)u;
 134
 135   for (i = 0; i < ITERS / NUM; i++)
 136     {
 137       struct timespec ts;
 138
 139       if ((ret = clock_gettime(CLOCK_REALTIME, &ts)) != 0)
 140         {
 141           tret = (void *)1;
 142           printf ("%u:clock_gettime failed: %s\n", seq, strerror (errno));
 143           goto out;
 144         }
 145       ts.tv_sec += 20;
 146
 147       if ((ret = pthread_mutex_lock (&mutex)) != 0)
 148         {
 149           tret = (void *)1;
 150           printf ("waiter[%u]:mutex_lock failed: %s\n", seq, strerror (ret));
 151           goto out;
 152         }
 153       pthread_cleanup_push (cleanup, NULL);
 154
 155       /* We should not time out either.  */
 156       if ((ret = pthread_cond_timedwait (&cond, &mutex, &ts)) != 0)
 157         {
 158           tret = (void *)1;
 159           printf ("waiter[%u]:timedwait failed: %s\n", seq, strerror (ret));
 160           goto unlock_out;
 161         }
 162       if ((ret = pthread_mutex_unlock (&mutex)) != 0)
 163         {
 164           tret = (void *)1;
 165           printf ("waiter[%u]:mutex_unlock failed: %s\n", seq, strerror (ret));
 166           goto out;
 167         }
 168       pthread_cleanup_pop (0);
 169     }
 170
 171 out:
 172   puts ("timed_waiter tests done");
 173   return tret;
 174
 175 unlock_out:
 176   if ((ret = pthread_mutex_unlock (&mutex)) != 0)
 177     printf ("waiter[%u]:mutex_unlock[2] failed: %s\n", seq, strerror (ret));
 178   goto out;
 179 }
 180
 181 int
 182 do_test_wait (thr_func f)
 183 {
 184   pthread_t w[NUM];
 185   pthread_t s;
 186   pthread_mutexattr_t attr;
 187   int i, j, ret = 0;
 188   void *thr_ret;
 189
 190   for (i = 0; i < COUNT; i++)
 191     {
 192       if ((ret = pthread_mutexattr_init (&attr)) != 0)
 193         {
 194           printf ("mutexattr_init failed: %s\n", strerror (ret));
 195           goto out;
 196         }
 197
 198       if ((ret = pthread_mutexattr_setprotocol (&attr, PTHREAD_PRIO_INHERIT)) != 0)
 199         {
 200           printf ("mutexattr_setprotocol failed: %s\n", strerror (ret));
 201           goto out;
 202         }
 203
 204       if ((ret = pthread_cond_init (&cond, NULL)) != 0)
 205         {
 206           printf ("cond_init failed: %s\n", strerror (ret));
 207           goto out;
 208         }
 209
 210       if ((ret = pthread_mutex_init (&mutex, &attr)) != 0)
 211         {
 212           printf ("mutex_init failed: %s\n", strerror (ret));
 213           goto out;
 214         }
 215
 216       for (j = 0; j < NUM; j++)
 217         if ((ret = pthread_create (&w[j], NULL, f, (void *)j)) != 0)
 218           {
 219             printf ("waiter[%d]: create failed: %s\n", j, strerror (ret));
 220             goto out;
 221           }
 222
 223       if ((ret = pthread_create (&s, NULL, signaller, NULL)) != 0)
 224         {
 225           printf ("signaller: create failed: %s\n", strerror (ret));
 226           goto out;
 227         }
 228
 229       for (j = 0; j < NUM; j++)
 230         {
 231           pthread_cancel (w[j]);
 232
 233           if ((ret = pthread_join (w[j], &thr_ret)) != 0)
 234             {
 235               printf ("waiter[%d]: join failed: %s\n", j, strerror (ret));
 236               goto out;
 237             }
 238
 239           if (thr_ret != NULL && thr_ret != PTHREAD_CANCELED)
 240             {
 241               ret = 1;
 242               goto out;
 243             }
 244         }
 245
 246       /* The signalling thread could have ended before it was cancelled.  */
 247       pthread_cancel (s);
 248
 249       if ((ret = pthread_join (s, &thr_ret)) != 0)
 250         {
 251           printf ("signaller: join failed: %s\n", strerror (ret));
 252           goto out;
 253         }
 254
 255       if (thr_ret != NULL && thr_ret != PTHREAD_CANCELED)
 256         {
 257           ret = 1;
 258           goto out;
 259         }
 260     }
 261
 262 out:
 263   return ret;
 264 }
 265
 266 int
 267 do_test (int argc, char **argv)
 268 {
 269   int ret = do_test_wait (waiter);
 270
 271   if (ret)
 272     return ret;
 273
 274   return do_test_wait (timed_waiter);
 275 }
 276
 277 #define TIMEOUT 5
 278 #include "../test-skeleton.c"