(main): Fix loop printing cleanup output.
[kopensolaris-gnu/glibc.git] / linuxthreads / ecmutex.c
1 /* Test of the error checking mutex and incidently also barriers.  */
2
3 #include <errno.h>
4 #include <pthread.h>
5 #include <stdio.h>
6 #include <stdlib.h>
7
8
9 static pthread_mutex_t locks[] =
10 {
11   PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP,
12   PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP,
13   PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP,
14   PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP,
15   PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
16 };
17 #define nlocks ((int) (sizeof (locks) / sizeof (locks[0])))
18
19 static pthread_barrier_t barrier;
20 #define SYNC pthread_barrier_wait (&barrier)
21
22 #define NTHREADS nlocks
23
24 #define ROUNDS 20
25
26
27 static void *
28 worker (void *arg)
29 {
30   /* We are locking the and unlocked the locks and check the errors.
31      Since we are using the error-checking variant the implementation
32      should report them.  */
33   int nr = (long int) arg;
34   int i;
35   void *result = NULL;
36   int retval;
37
38   for (i = 0; i < ROUNDS; ++i)
39     {
40       /* Skip the rounds which would make other == own.  */
41       if (i % nlocks == 0)
42         continue;
43
44       /* Get the "own" mutex.  */
45       if (pthread_mutex_trylock (&locks[nr]) != 0)
46         {
47           printf ("thread %d failed getting own mutex\n", nr);
48           result = (void *) 1;
49         }
50
51       /* Try locking "own" mutex again.  */
52       retval = pthread_mutex_lock (&locks[nr]);
53       if (retval != EDEADLK)
54         {
55           printf ("thread %d failed getting own mutex\n", nr);
56           result = (void *) 1;
57         }
58
59       /* Try to get a different semaphore.  */
60       SYNC;
61       retval = pthread_mutex_trylock (&locks[(nr + i) % nlocks]);
62       if (retval != EBUSY)
63         {
64           printf ("thread %d didn't deadlock on getting %d's lock\n",
65                   nr, (nr + i) % nlocks);
66           result = (void *) 1;
67         }
68
69       /* Try unlocking other's lock.  */
70       retval = pthread_mutex_unlock (&locks[(nr + i) % nlocks]);
71       if (retval != EPERM)
72         {
73           printf ("thread %d managed releasing mutex %d\n",
74                   nr, (nr + i) % nlocks);
75           result = (void *) 1;
76         }
77
78       /* All lock one mutex now.  */
79       SYNC;
80       retval = pthread_mutex_lock (&locks[i % nlocks]);
81       if (nr == (i % nlocks))
82         {
83           if (retval != EDEADLK)
84             {
85               printf ("thread %d didn't deadlock on getting %d's lock\n",
86                       nr, (nr + i) % nlocks);
87               result = (void *) 1;
88             }
89           if (pthread_mutex_unlock (&locks[i % nlocks]) != 0)
90             {
91               printf ("thread %d failed releasing own mutex\n", nr);
92               result = (void *) 1;
93             }
94         }
95       else
96         {
97           if (retval != 0)
98             {
99               printf ("thread %d failed acquiring mutex %d\n",
100                       nr, i % nlocks);
101               result = (void *) 1;
102             }
103           else if (pthread_mutex_unlock (&locks[i % nlocks]) != 0)
104             {
105               printf ("thread %d failed releasing mutex %d\n",
106                       nr, i % nlocks);
107               result = (void *) 1;
108             }
109         }
110
111       /* Unlock the own lock.  */
112       SYNC;
113       if (nr != (i % nlocks) && pthread_mutex_unlock (&locks[nr]) != 0)
114         {
115           printf ("thread %d failed releasing own mutex\n", nr);
116           result = (void *) 1;
117         }
118
119       /* Try unlocking again.  */
120       retval = pthread_mutex_unlock (&locks[nr]);
121       if (retval == 0)
122         {
123           printf ("thread %d managed releasing own mutex twice\n", nr);
124           result = (void *) 1;
125         }
126     }
127
128   return result;
129 }
130
131
132 #define TEST_FUNCTION do_test ()
133 static int
134 do_test (void)
135 {
136   pthread_t threads[NTHREADS];
137   int i;
138   void *res;
139   int result = 0;
140
141   pthread_barrier_init (&barrier, NULL, NTHREADS);
142
143   for (i = 0; i < NTHREADS; ++i)
144     if (pthread_create (&threads[i], NULL, worker, (void *) (long int) i) != 0)
145       {
146         printf ("failed to create thread %d: %m\n", i);
147         exit (1);
148       }
149
150   for (i = 0; i < NTHREADS; ++i)
151     if (pthread_join (threads[i], &res) != 0 || res != NULL)
152       result = 1;
153
154   return result;
155 }
156
157 #include "../test-skeleton.c"