Test for pshared robust mutexes.
[kopensolaris-gnu/glibc.git] / nptl / tst-robust8.c
1 #include <pthread.h>
2 #include <signal.h>
3 #include <stdint.h>
4 #include <stdio.h>
5 #include <stdlib.h>
6 #include <string.h>
7 #include <unistd.h>
8 #include <sys/mman.h>
9 #include <sys/wait.h>
10
11
12
13
14 static void prepare (void);
15 #define PREPARE(argc, argv) prepare ()
16 static int do_test (void);
17 #define TEST_FUNCTION do_test ()
18 #define TIMEOUT 3
19 #include "../test-skeleton.c"
20
21
22 static int fd;
23 #define N 100
24
25 static void
26 prepare (void)
27 {
28   fd = create_temp_file ("tst-robust8", NULL);
29   if (fd == -1)
30     exit (1);
31 }
32
33
34 #define THESIGNAL SIGKILL
35 #define ROUNDS 5
36 #define THREADS 9
37
38
39 static const struct timespec before = { 0, 0 };
40
41
42 static pthread_mutex_t *map;
43
44
45 static void *
46 tf (void *arg)
47 {
48   long int nr = (long int) arg;
49   int fct = nr % 3;
50
51   uint8_t state[N];
52   memset (state, '\0', sizeof (state));
53
54   while (1)
55     {
56       int r = random () % N;
57       if (state[r] == 0)
58         {
59           int e;
60
61           switch (fct)
62             {
63             case 0:
64               e = pthread_mutex_lock (&map[r]);
65               if (e != 0)
66                 {
67                   printf ("mutex_lock of %d in thread %ld failed with %d\n",
68                           r, nr, e);
69                   exit (1);
70                 }
71               state[r] = 1;
72               break;
73             case 1:
74               e = pthread_mutex_timedlock (&map[r], &before);
75               if (e != 0 && e != ETIMEDOUT)
76                 {
77                   printf ("\
78 mutex_timedlock of %d in thread %ld failed with %d\n",
79                           r, nr, e);
80                   exit (1);
81                 }
82               break;
83             default:
84               e = pthread_mutex_trylock (&map[r]);
85               if (e != 0 && e != EBUSY)
86                 {
87                   printf ("mutex_trylock of %d in thread %ld failed with %d\n",
88                           r, nr, e);
89                   exit (1);
90                 }
91               break;
92             }
93
94           if (e == EOWNERDEAD)
95             pthread_mutex_consistent_np (&map[r]);
96
97           if (e == 0 || e == EOWNERDEAD)
98             state[r] = 1;
99         }
100       else
101         {
102           int e = pthread_mutex_unlock (&map[r]);
103           if (e != 0)
104             {
105               printf ("mutex_unlock of %d in thread %ld failed with %d\n",
106                       r, nr, e);
107               exit (1);
108             }
109
110           state[r] = 0;
111         }
112     }
113 }
114
115
116 static void
117 child (int round)
118 {
119   for (int thread = 1; thread <= THREADS; ++thread)
120     {
121       pthread_t th;
122       if (pthread_create (&th, NULL, tf, (void *) (long int) thread) != 0)
123         {
124           printf ("cannot create thread %d in round %d\n", thread, round);
125           exit (1);
126         }
127     }
128
129   struct timespec ts;
130   ts.tv_sec = 0;
131   ts.tv_nsec = 1000000000 / ROUNDS;
132   while (nanosleep (&ts, &ts) != 0)
133     /* nothing */;
134
135   /* Time to die.  */
136   kill (getpid (), THESIGNAL);
137
138   /* We better never get here.  */
139   abort ();
140 }
141
142
143 static int
144 do_test (void)
145 {
146   if (ftruncate (fd, N * sizeof (pthread_mutex_t)) != 0)
147     {
148       puts ("cannot size new file");
149       return 1;
150     }
151
152   map = mmap (NULL, N * sizeof (pthread_mutex_t), PROT_READ | PROT_WRITE,
153               MAP_SHARED, fd, 0);
154   if (map == MAP_FAILED)
155     {
156       puts ("mapping failed");
157       return 1;
158     }
159
160   pthread_mutexattr_t ma;
161   if (pthread_mutexattr_init (&ma) != 0)
162     {
163       puts ("mutexattr_init failed");
164       return 0;
165     }
166   if (pthread_mutexattr_setrobust_np (&ma, PTHREAD_MUTEX_ROBUST_NP) != 0)
167     {
168       puts ("mutexattr_setrobust failed");
169       return 1;
170     }
171   if (pthread_mutexattr_setpshared (&ma, PTHREAD_PROCESS_SHARED) != 0)
172     {
173       puts ("mutexattr_setpshared failed");
174       return 1;
175     }
176
177   for (int round = 1; round <= ROUNDS; ++round)
178     {
179       for (int n = 0; n < N; ++n)
180         {
181           int e = pthread_mutex_init (&map[n], &ma);
182           if (e == ENOTSUP)
183             {
184               puts ("cannot support pshared robust mutexes");
185               return 0;
186             }
187           if (e != 0)
188             {
189               printf ("mutex_init %d in round %d failed\n", n + 1, round);
190               return 1;
191             }
192         }
193
194       pid_t p = fork ();
195       if (p == -1)
196         {
197           printf ("fork in round %d failed\n", round);
198           return 1;
199         }
200       if (p == 0)
201         child (round);
202
203       int status;
204       if (TEMP_FAILURE_RETRY (waitpid (p, &status, 0)) != p)
205         {
206           printf ("waitpid in round %d failed\n", round);
207           return 1;
208         }
209       if (!WIFSIGNALED (status))
210         {
211           printf ("child did not die of a signal in round %d\n", round);
212           return 1;
213         }
214       if (WTERMSIG (status) != THESIGNAL)
215         {
216           printf ("child did not die of signal %d in round %d\n",
217                   THESIGNAL, round);
218           return 1;
219         }
220
221       for (int n = 0; n < N; ++n)
222         {
223           int e = pthread_mutex_lock (&map[n]);
224           if (e != 0 && e != EOWNERDEAD)
225             {
226               printf ("mutex_lock %d failed in round %d\n", n + 1, round);
227               return 1;
228             }
229         }
230
231       for (int n = 0; n < N; ++n)
232         if (pthread_mutex_unlock (&map[n]) != 0)
233           {
234             printf ("mutex_unlock %d failed in round %d\n", n + 1, round);
235             return 1;
236           }
237
238       for (int n = 0; n < N; ++n)
239         {
240           int e = pthread_mutex_destroy (&map[n]);
241           if (e != 0)
242             {
243               printf ("mutex_destroy %d in round %d failed with %d\n",
244                       n + 1, round, e);
245               printf("nusers = %d\n", (int) map[n].__data.__nusers);
246               return 1;
247             }
248         }
249     }
250
251   if (pthread_mutexattr_destroy (&ma) != 0)
252     {
253       puts ("mutexattr_destroy failed");
254       return 1;
255     }
256
257   if (munmap (map, N * sizeof (pthread_mutex_t)) != 0)
258     {
259       puts ("munmap failed");
260       return 1;
261     }
262
263   return 0;
264 }