text: /* Verify that condition variables synchronized by PI mutexes don't hang on
     on cancellation.
     Copyright (C) 2012 Free Software Foundation, Inc.
     This file is part of the GNU C Library.
  
     The GNU C Library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) any later version.
  
     The GNU C Library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.
  
     You should have received a copy of the GNU Lesser General Public
     License along with the GNU C Library; if not, see
     <http://www.gnu.org/licenses/>.  */
  
  #include <pthread.h>
  #include <stdio.h>
  #include <stdlib.h>
  #include <stdint.h>
  #include <string.h>
  #include <errno.h>
  #include <sys/types.h>
  #include <sys/syscall.h>
  #include <unistd.h>
  #include <sys/time.h>
  #include <time.h>
  
  #define NUM 5
  #define ITERS 10000
  #define COUNT 100
  
  typedef void *(*thr_func) (void *);
  
  pthread_mutex_t mutex;
  pthread_cond_t cond;
  
  void cleanup (void *u)
  {
    /* pthread_cond_wait should always return with the mutex locked.  */
    if (pthread_mutex_unlock (&mutex))
      abort ();
  }
  
  void *
  signaller (void *u)
  {
    int i, ret = 0;
    void *tret = NULL;
  
    for (i = 0; i < ITERS; i++)
      {
        if ((ret = pthread_mutex_lock (&mutex)) != 0)
          {
  	  tret = (void *)1;
  	  printf ("signaller:mutex_lock failed: %s\n", strerror (ret));
  	  goto out;
  	}
        if ((ret = pthread_cond_signal (&cond)) != 0)
          {
  	  tret = (void *)1;
  	  printf ("signaller:signal failed: %s\n", strerror (ret));
  	  goto unlock_out;
  	}
        if ((ret = pthread_mutex_unlock (&mutex)) != 0)
          {
  	  tret = (void *)1;
  	  printf ("signaller:mutex_unlock failed: %s\n", strerror (ret));
  	  goto out;
  	}
        pthread_testcancel ();
      }
  
  out:
    return tret;
  
  unlock_out:
    if ((ret = pthread_mutex_unlock (&mutex)) != 0)
      printf ("signaller:mutex_unlock[2] failed: %s\n", strerror (ret));
    goto out;
  }
  
  void *
  waiter (void *u)
  {
    int i, ret = 0;
    void *tret = NULL;
    int seq = (uintptr_t) u;
  
    for (i = 0; i < ITERS / NUM; i++)
      {
        if ((ret = pthread_mutex_lock (&mutex)) != 0)
          {
  	  tret = (void *) (uintptr_t) 1;
  	  printf ("waiter[%u]:mutex_lock failed: %s\n", seq, strerror (ret));
  	  goto out;
  	}
        pthread_cleanup_push (cleanup, NULL);
  
        if ((ret = pthread_cond_wait (&cond, &mutex)) != 0)
          {
  	  tret = (void *) (uintptr_t) 1;
  	  printf ("waiter[%u]:wait failed: %s\n", seq, strerror (ret));
  	  goto unlock_out;
  	}
  
        if ((ret = pthread_mutex_unlock (&mutex)) != 0)
          {
  	  tret = (void *) (uintptr_t) 1;
  	  printf ("waiter[%u]:mutex_unlock failed: %s\n", seq, strerror (ret));
  	  goto out;
  	}
        pthread_cleanup_pop (0);
      }
  
  out:
    puts ("waiter tests done");
    return tret;
  
  unlock_out:
    if ((ret = pthread_mutex_unlock (&mutex)) != 0)
      printf ("waiter:mutex_unlock[2] failed: %s\n", strerror (ret));
    goto out;
  }
  
  void *
  timed_waiter (void *u)
  {
    int i, ret;
    void *tret = NULL;
    int seq = (uintptr_t) u;
  
    for (i = 0; i < ITERS / NUM; i++)
      {
        struct timespec ts;
  
        if ((ret = clock_gettime(CLOCK_REALTIME, &ts)) != 0)
          {
  	  tret = (void *) (uintptr_t) 1;
  	  printf ("%u:clock_gettime failed: %s\n", seq, strerror (errno));
  	  goto out;
  	}
        ts.tv_sec += 20;
  
        if ((ret = pthread_mutex_lock (&mutex)) != 0)
          {
  	  tret = (void *) (uintptr_t) 1;
  	  printf ("waiter[%u]:mutex_lock failed: %s\n", seq, strerror (ret));
  	  goto out;
  	}
        pthread_cleanup_push (cleanup, NULL);
  
        /* We should not time out either.  */
        if ((ret = pthread_cond_timedwait (&cond, &mutex, &ts)) != 0)
          {
  	  tret = (void *) (uintptr_t) 1;
  	  printf ("waiter[%u]:timedwait failed: %s\n", seq, strerror (ret));
  	  goto unlock_out;
  	}
        if ((ret = pthread_mutex_unlock (&mutex)) != 0)
          {
  	  tret = (void *) (uintptr_t) 1;
  	  printf ("waiter[%u]:mutex_unlock failed: %s\n", seq, strerror (ret));
  	  goto out;
  	}
        pthread_cleanup_pop (0);
      }
  
  out:
    puts ("timed_waiter tests done");
    return tret;
  
  unlock_out:
    if ((ret = pthread_mutex_unlock (&mutex)) != 0)
      printf ("waiter[%u]:mutex_unlock[2] failed: %s\n", seq, strerror (ret));
    goto out;
  }
  
  int
  do_test_wait (thr_func f)
  {
    pthread_t w[NUM];
    pthread_t s;
    pthread_mutexattr_t attr;
    int i, j, ret = 0;
    void *thr_ret;
  
    for (i = 0; i < COUNT; i++)
      {
        if ((ret = pthread_mutexattr_init (&attr)) != 0)
          {
  	  printf ("mutexattr_init failed: %s\n", strerror (ret));
  	  goto out;
  	}
  
        if ((ret = pthread_mutexattr_setprotocol (&attr,
                                                  PTHREAD_PRIO_INHERIT)) != 0)
          {
  	  printf ("mutexattr_setprotocol failed: %s\n", strerror (ret));
  	  goto out;
  	}
  
        if ((ret = pthread_cond_init (&cond, NULL)) != 0)
          {
  	  printf ("cond_init failed: %s\n", strerror (ret));
  	  goto out;
  	}
  
        if ((ret = pthread_mutex_init (&mutex, &attr)) != 0)
          {
  	  printf ("mutex_init failed: %s\n", strerror (ret));
  	  goto out;
  	}
  
        for (j = 0; j < NUM; j++)
          if ((ret = pthread_create (&w[j], NULL,
                                     f, (void *) (uintptr_t) j)) != 0)
  	  {
  	    printf ("waiter[%d]: create failed: %s\n", j, strerror (ret));
  	    goto out;
  	  }
  
        if ((ret = pthread_create (&s, NULL, signaller, NULL)) != 0)
          {
  	  printf ("signaller: create failed: %s\n", strerror (ret));
  	  goto out;
  	}
  
        for (j = 0; j < NUM; j++)
          {
            pthread_cancel (w[j]);
  
            if ((ret = pthread_join (w[j], &thr_ret)) != 0)
  	    {
  	      printf ("waiter[%d]: join failed: %s\n", j, strerror (ret));
  	      goto out;
  	    }
  
            if (thr_ret != NULL && thr_ret != PTHREAD_CANCELED)
  	    {
  	      ret = 1;
  	      goto out;
  	    }
          }
  
        /* The signalling thread could have ended before it was cancelled.  */
        pthread_cancel (s);
  
        if ((ret = pthread_join (s, &thr_ret)) != 0)
          {
  	  printf ("signaller: join failed: %s\n", strerror (ret));
  	  goto out;
  	}
  
        if (thr_ret != NULL && thr_ret != PTHREAD_CANCELED)
          {
            ret = 1;
            goto out;
          }
      }
  
  out:
    return ret;
  }
  
  int
  do_test (int argc, char **argv)
  {
    int ret = do_test_wait (waiter);
  
    if (ret)
      return ret;
  
    return do_test_wait (timed_waiter);
  }
  
  #define TIMEOUT 5
  #include "../test-skeleton.c"
  