nptl/tst-cond8.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 <stdlib.h>
  24 #include <time.h>
  25 #include <sys/time.h>
  26
  27
  28 static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
  29 static pthread_mutex_t mut = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
  30
  31 static pthread_barrier_t bar;
  32
  33
  34 static void
  35 ch (void *arg)
  36 {
  37   int e = pthread_mutex_lock (&mut);
  38   if (e == 0)
  39     {
  40       puts ("mutex not locked at all by cond_wait");
  41       exit (1);
  42     }
  43
  44   if (e != EDEADLK)
  45     {
  46       puts ("no deadlock error signaled");
  47       exit (1);
  48     }
  49
  50   if (pthread_mutex_unlock (&mut) != 0)
  51     {
  52       puts ("ch: cannot unlock mutex");
  53       exit (1);
  54     }
  55 }
  56
  57
  58 static void *
  59 tf1 (void *p)
  60 {
  61   int err;
  62
  63   if (pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL) != 0
  64       || pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, NULL) != 0)
  65     {
  66       puts ("cannot set cancellation options");
  67       exit (1);
  68     }
  69
  70   err = pthread_mutex_lock (&mut);
  71   if (err != 0)
  72     {
  73       puts ("child: cannot get mutex");
  74       exit (1);
  75     }
  76
  77   err = pthread_barrier_wait (&bar);
  78   if (err != 0 && err != PTHREAD_BARRIER_SERIAL_THREAD)
  79     {
  80       printf ("barrier_wait returned %d\n", err);
  81       exit (1);
  82     }
  83
  84   puts ("child: got mutex; waiting");
  85
  86   pthread_cleanup_push (ch, NULL);
  87
  88   pthread_cond_wait (&cond, &mut);
  89
  90   pthread_cleanup_pop (0);
  91
  92   puts ("child: cond_wait should not have returned");
  93
  94   return NULL;
  95 }
  96
  97
  98 static void *
  99 tf2 (void *p)
 100 {
 101   int err;
 102
 103   if (pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL) != 0
 104       || pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, NULL) != 0)
 105     {
 106       puts ("cannot set cancellation options");
 107       exit (1);
 108     }
 109
 110   err = pthread_mutex_lock (&mut);
 111   if (err != 0)
 112     {
 113       puts ("child: cannot get mutex");
 114       exit (1);
 115     }
 116
 117   err = pthread_barrier_wait (&bar);
 118   if (err != 0 && err != PTHREAD_BARRIER_SERIAL_THREAD)
 119     {
 120       printf ("barrier_wait returned %d\n", err);
 121       exit (1);
 122     }
 123
 124   puts ("child: got mutex; waiting");
 125
 126   pthread_cleanup_push (ch, NULL);
 127
 128   /* Current time.  */
 129   struct timeval tv;
 130   (void) gettimeofday (&tv, NULL);
 131   /* +1000 seconds in correct format.  */
 132   struct timespec ts;
 133   TIMEVAL_TO_TIMESPEC (&tv, &ts);
 134   ts.tv_sec += 1000;
 135
 136   pthread_cond_timedwait (&cond, &mut, &ts);
 137
 138   pthread_cleanup_pop (0);
 139
 140   puts ("child: cond_wait should not have returned");
 141
 142   return NULL;
 143 }
 144
 145
 146 static int
 147 do_test (void)
 148 {
 149   pthread_t th;
 150   int err;
 151
 152   printf ("&cond = %p\n&mut = %p\n", &cond, &mut);
 153
 154   puts ("parent: get mutex");
 155
 156   err = pthread_barrier_init (&bar, NULL, 2);
 157   if (err != 0)
 158     {
 159       puts ("parent: cannot init barrier");
 160       exit (1);
 161     }
 162
 163   puts ("parent: create child");
 164
 165   err = pthread_create (&th, NULL, tf1, NULL);
 166   if (err != 0)
 167     {
 168       puts ("parent: cannot create thread");
 169       exit (1);
 170     }
 171
 172   puts ("parent: wait for child to lock mutex");
 173
 174   err = pthread_barrier_wait (&bar);
 175   if (err != 0 && err != PTHREAD_BARRIER_SERIAL_THREAD)
 176     {
 177       puts ("parent: cannot wait for barrier");
 178       exit (1);
 179     }
 180
 181   err = pthread_mutex_lock (&mut);
 182   if (err != 0)
 183     {
 184       puts ("parent: mutex_lock failed");
 185       exit (1);
 186     }
 187
 188   err = pthread_mutex_unlock (&mut);
 189   if (err != 0)
 190     {
 191       puts ("parent: mutex_unlock failed");
 192       exit (1);
 193     }
 194
 195   if (pthread_cancel (th) != 0)
 196     {
 197       puts ("cannot cancel thread");
 198       exit (1);
 199     }
 200
 201   void *r;
 202   err = pthread_join (th, &r);
 203   if (err != 0)
 204     {
 205       puts ("parent: failed to join");
 206       exit (1);
 207     }
 208
 209   if (r != PTHREAD_CANCELED)
 210     {
 211       puts ("child hasn't been canceled");
 212       exit (1);
 213     }
 214
 215
 216
 217   puts ("parent: create 2nd child");
 218
 219   err = pthread_create (&th, NULL, tf2, NULL);
 220   if (err != 0)
 221     {
 222       puts ("parent: cannot create thread");
 223       exit (1);
 224     }
 225
 226   puts ("parent: wait for child to lock mutex");
 227
 228   err = pthread_barrier_wait (&bar);
 229   if (err != 0 && err != PTHREAD_BARRIER_SERIAL_THREAD)
 230     {
 231       puts ("parent: cannot wait for barrier");
 232       exit (1);
 233     }
 234
 235   err = pthread_mutex_lock (&mut);
 236   if (err != 0)
 237     {
 238       puts ("parent: mutex_lock failed");
 239       exit (1);
 240     }
 241
 242   err = pthread_mutex_unlock (&mut);
 243   if (err != 0)
 244     {
 245       puts ("parent: mutex_unlock failed");
 246       exit (1);
 247     }
 248
 249   if (pthread_cancel (th) != 0)
 250     {
 251       puts ("cannot cancel thread");
 252       exit (1);
 253     }
 254
 255   err = pthread_join (th, &r);
 256   if (err != 0)
 257     {
 258       puts ("parent: failed to join");
 259       exit (1);
 260     }
 261
 262   if (r != PTHREAD_CANCELED)
 263     {
 264       puts ("child hasn't been canceled");
 265       exit (1);
 266     }
 267
 268   puts ("done");
 269
 270   return 0;
 271 }
 272
 273
 274 #define TEST_FUNCTION do_test ()
 275 #include "../test-skeleton.c"