nptl/tst-rwlock8.c

   1 /* Test program for timedout read/write lock functions.
   2    Copyright (C) 2000-2020 Free Software Foundation, Inc.
   3    Contributed by Ulrich Drepper <drepper@redhat.com>, 2000.
   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 License as
   7    published by the Free Software Foundation; either version 2.1 of the
   8    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; see the file COPYING.LIB.  If
  17    not, see <https://www.gnu.org/licenses/>.  */
  18
  19 #include <errno.h>
  20 #include <error.h>
  21 #include <pthread.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <time.h>
  25 #include <unistd.h>
  26
  27
  28 #define NWRITERS 15
  29 #define WRITETRIES 10
  30 #define NREADERS 15
  31 #define READTRIES 15
  32
  33 #define DELAY   1000000
  34
  35 #ifndef KIND
  36 # define KIND PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP
  37 #endif
  38
  39 static pthread_rwlock_t lock;
  40
  41
  42 static void *
  43 writer_thread (void *nr)
  44 {
  45   struct timespec delay;
  46   int n;
  47
  48   delay.tv_sec = 0;
  49   delay.tv_nsec = DELAY;
  50
  51   for (n = 0; n < WRITETRIES; ++n)
  52     {
  53       printf ("writer thread %ld tries again\n", (long int) nr);
  54
  55       if (pthread_rwlock_wrlock (&lock) != 0)
  56         {
  57           puts ("wrlock failed");
  58           exit (1);
  59         }
  60
  61       printf ("writer thread %ld succeeded\n", (long int) nr);
  62
  63       nanosleep (&delay, NULL);
  64
  65       if (pthread_rwlock_unlock (&lock) != 0)
  66         {
  67           puts ("unlock for writer failed");
  68           exit (1);
  69         }
  70
  71       printf ("writer thread %ld released\n", (long int) nr);
  72     }
  73
  74   return NULL;
  75 }
  76
  77
  78 static void *
  79 reader_thread (void *nr)
  80 {
  81   struct timespec delay;
  82   int n;
  83
  84   delay.tv_sec = 0;
  85   delay.tv_nsec = DELAY;
  86
  87   for (n = 0; n < READTRIES; ++n)
  88     {
  89       printf ("reader thread %ld tries again\n", (long int) nr);
  90
  91       if (pthread_rwlock_rdlock (&lock) != 0)
  92         {
  93           puts ("rdlock failed");
  94           exit (1);
  95         }
  96
  97       printf ("reader thread %ld succeeded\n", (long int) nr);
  98
  99       nanosleep (&delay, NULL);
 100
 101       if (pthread_rwlock_unlock (&lock) != 0)
 102         {
 103           puts ("unlock for reader failed");
 104           exit (1);
 105         }
 106
 107       printf ("reader thread %ld released\n", (long int) nr);
 108     }
 109
 110   return NULL;
 111 }
 112
 113
 114 static int
 115 do_test (void)
 116 {
 117   pthread_t thwr[NWRITERS];
 118   pthread_t thrd[NREADERS];
 119   int n;
 120   void *res;
 121   pthread_rwlockattr_t a;
 122
 123   if (pthread_rwlockattr_init (&a) != 0)
 124     {
 125       puts ("rwlockattr_t failed");
 126       exit (1);
 127     }
 128
 129   if (pthread_rwlockattr_setkind_np (&a, KIND) != 0)
 130     {
 131       puts ("rwlockattr_setkind failed");
 132       exit (1);
 133     }
 134
 135   if (pthread_rwlock_init (&lock, &a) != 0)
 136     {
 137       puts ("rwlock_init failed");
 138       exit (1);
 139     }
 140
 141   /* Make standard error the same as standard output.  */
 142   dup2 (1, 2);
 143
 144   /* Make sure we see all message, even those on stdout.  */
 145   setvbuf (stdout, NULL, _IONBF, 0);
 146
 147   for (n = 0; n < NWRITERS; ++n)
 148     if (pthread_create (&thwr[n], NULL, writer_thread,
 149                         (void *) (long int) n) != 0)
 150       {
 151         puts ("writer create failed");
 152         exit (1);
 153       }
 154
 155   for (n = 0; n < NREADERS; ++n)
 156     if (pthread_create (&thrd[n], NULL, reader_thread,
 157                         (void *) (long int) n) != 0)
 158       {
 159         puts ("reader create failed");
 160         exit (1);
 161       }
 162
 163   /* Wait for all the threads.  */
 164   for (n = 0; n < NWRITERS; ++n)
 165     if (pthread_join (thwr[n], &res) != 0)
 166       {
 167         puts ("writer join failed");
 168         exit (1);
 169       }
 170   for (n = 0; n < NREADERS; ++n)
 171     if (pthread_join (thrd[n], &res) != 0)
 172       {
 173         puts ("reader join failed");
 174         exit (1);
 175       }
 176
 177   return 0;
 178 }
 179
 180 #define TIMEOUT 30
 181 #define TEST_FUNCTION do_test ()
 182 #include "../test-skeleton.c"