Whamcloud - gitweb
46d05e1918339f46c860c17dcf69110da1bb86bc
[fs/lustre-release.git] / lustre / tests / mpi / parallel_grouplock.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.gnu.org/licenses/gpl-2.0.html
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Use is subject to license terms.
25  */
26 /*
27  * This file is part of Lustre, http://www.lustre.org/
28  * Lustre is a trademark of Sun Microsystems, Inc.
29  *
30  * lustre/tests/parallel_grouplock.c
31  *
32  * Author: You Feng <youfeng@clusterfs.com>
33  */
34
35 #include <limits.h>
36 #include <mpi.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <sys/types.h>
41 #include <asm/types.h>
42 #include <sys/stat.h>
43 #include <fcntl.h>
44 #include <sys/ioctl.h>
45 #include <unistd.h>
46 #include <time.h>
47 #include <errno.h>
48 #include <lustre/lustre_user.h>
49 #include "lp_utils.h"
50
51 #define LPGL_BUF_LEN 8192
52 #define LPGL_TEST_ITEMS 12
53
54 #define MIN_GLHOST 5
55
56 #define MAX_WAIT_TRIES            10
57 #define WAIT_TIME                  1  /* secs */
58 #define ONE_MB               1048576  /*   1 MB */
59 #define MIN_LGBUF_SIZE     536870912  /* 512 MB */
60 #define MAX_LGBUF_SIZE     536870912  /* 512 MB */
61 // #define MAX_LGBUF_SIZE    1073741824  /*   1 GB */
62
63 #define READ    1
64 #define WRITE   2
65 #define IOCTL   3
66 #define CLOSE   4
67
68 int rank = 0;
69 int size = 0;
70
71 char *testdir = NULL;
72 int   only_test;
73
74 char  buf[LPGL_BUF_LEN];
75 char *lgbuf;
76 int   lgbuf_size;
77 char  filename[MAX_FILENAME_LEN];
78 char  errmsg[MAX_FILENAME_LEN+20];
79
80 static void
81 alloc_lgbuf()
82 {
83
84         if (lgbuf)
85                 return;
86
87         lgbuf_size = MAX_LGBUF_SIZE;
88         for (; lgbuf_size >= MIN_LGBUF_SIZE; lgbuf_size -= ONE_MB)
89                 if ((lgbuf = (char *)malloc(lgbuf_size)) != NULL)
90                         return;
91
92         FAIL("malloc of large buffer failed.\n");
93 }
94
95 static inline void
96 read_buf(int fd)
97 {
98         int pos, rc;
99
100         rc = read(fd, buf, sizeof(buf));
101         if (rc == -1) {
102                 pos = lseek(fd, 0, SEEK_CUR);
103                 sprintf(errmsg, "read of file %s at pos %d for %zu bytes "
104                         "returned %d: (%d) %s.\n",
105                         filename, pos, sizeof(buf), rc, errno, strerror(errno));
106                 FAIL(errmsg);
107         } else if (rc != sizeof(buf)) {
108                 pos = lseek(fd, 0, SEEK_CUR);
109                 sprintf(errmsg, "read of file %s at pos %d for %zu bytes "
110                         "returned %d.\n",
111                         filename, pos, sizeof(buf), rc);
112                 FAIL(errmsg);
113         }
114 }
115
116 static inline void
117 write_buf(int fd, int index)
118 {
119         int pos = index * sizeof(buf);
120         int rc;
121
122         memset(buf, index, sizeof(buf));
123         lseek(fd, pos, SEEK_SET);
124         rc = write(fd, buf, sizeof(buf));
125         if (rc == -1) {
126                 sprintf(errmsg, "write of file %s at pos %d for %zu bytes "
127                         "returned %d: (%d) %s.\n",
128                         filename, pos, sizeof(buf), rc, errno, strerror(errno));
129                 FAIL(errmsg);
130         } else if (rc != sizeof(buf)) {
131                 sprintf(errmsg, "write of file %s at pos %d for %zu bytes "
132                         "returned %d.\n",
133                         filename, pos, sizeof(buf), rc);
134                 FAIL(errmsg);
135         }
136 }
137
138 /*
139  * task0 attempts GR(gid=1) -- granted immediately
140  * task1 attempts PR|PW -- blocked, goes on waiting list
141  * task2 attempts GR(gid=1) -> should be granted
142  * task2 writes to file and releases GR(gid=1)
143  * task0 waits for task2 to complete its processing
144  * task0 writes to file and releases GR(gid=1)
145  * task1 PR|PW should be granted and reads the file
146  */
147 void grouplock_test1(char *filename, int fd, int blocking_op, int unlock_op)
148 {
149         MPI_Request req1, req2;
150         int iter, flag1, flag2, temp1, temp2;
151         int i, rc, gid = 1;
152
153         if (rank == 0) {
154                 if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) {
155                         sprintf(errmsg,
156                                 "ioctl GROUP_LOCK of file %s: (%d) %s.\n",
157                                 filename, errno, strerror(errno));
158                         FAIL(errmsg);
159                 }
160         }
161
162         MPI_Barrier(MPI_COMM_WORLD);
163
164         switch (rank) {
165         case 1:
166                 if (blocking_op == WRITE) {
167                         write_buf(fd, rank);
168                         lseek(fd, 0, SEEK_SET);
169                 }
170
171                 for (i = 0; i <= 2; i++)
172                         read_buf(fd);
173
174                 MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD);
175                 break;
176         case 2:
177                 /* Wait for task1 to progress. This could be racey. */
178                 sleep(WAIT_TIME);
179
180                 if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) {
181                         sprintf(errmsg,
182                                 "ioctl GROUP_LOCK of file %s: (%d) %s.\n",
183                                 filename, errno, strerror(errno));
184                         FAIL(errmsg);
185                 }
186
187                 write_buf(fd, rank);
188
189                 if (unlock_op == CLOSE)
190                         rc = close(fd);
191                 else
192                         rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid);
193
194                 if (rc == -1) {
195                         sprintf(errmsg,
196                                 "%s release GROUP_LOCK of file %s: (%d) %s.\n",
197                                 (unlock_op == CLOSE) ? "close" : "ioctl",
198                                 filename, errno, strerror(errno));
199                         FAIL(errmsg);
200                 }
201                 MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD);
202                 break;
203         case 0:
204                 /* PR|PW task will tell us when it completes */
205                 MPI_Irecv(&temp1, 1, MPI_INT, 1, 1, MPI_COMM_WORLD, &req1);
206                 /* 2nd locking task will tell us when it completes */
207                 MPI_Irecv(&temp2, 1, MPI_INT, 2, 1, MPI_COMM_WORLD, &req2);
208
209                 /* Wait for task2 to complete. */
210                 iter = MAX_WAIT_TRIES;
211                 do {
212                         iter--;
213                         if (!iter) {
214                                 FAIL("2nd locking task is not progressing\n");
215                         }
216
217                         sleep(WAIT_TIME);
218
219                         MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE);
220                         if (flag1) {
221                                 FAIL("PR|PW task progressed even though GROUP "
222                                      "lock is held\n");
223                         }
224
225                         MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE);
226                 } while (!flag2);
227
228                 /* Make sure task1 is still waiting. */
229                 iter = MAX_WAIT_TRIES;
230                 do {
231                         iter--;
232                         sleep(WAIT_TIME);
233                         MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE);
234                         if (flag1) {
235                                 FAIL("PR|PW task progressed even though "
236                                      "GROUP lock is held\n");
237                         }
238                 } while (iter);
239
240                 write_buf(fd, rank);
241
242                 /* Now we need to release the lock */
243                 if ((rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid)) == -1) {
244                         sprintf(errmsg,
245                                 "ioctl GROUP_UNLOCK of file %s: (%d) %s.\n",
246                                 filename, errno, strerror(errno));
247                         FAIL(errmsg);
248                 }
249
250                 /* Wait for task1 to complete. */
251                 iter = MAX_WAIT_TRIES;
252                 do {
253                         iter--;
254                         if (!iter) {
255                                 FAIL("PR|PW task is not progressing even "
256                                      "though GROUP lock was released\n");
257                                 break;
258                         }
259                         sleep(WAIT_TIME);
260                         MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE);
261                 } while (!flag1);
262
263                 break;
264         }
265 }
266
267 /*
268  * task0 attempts GR(gid=1) -- granted immediately
269  * task1 attempts GR(gid=2) -- blocked
270  * task2 attempts PR|PW -- blocked
271  * task3 attempts GR(gid=2) -- blocked
272  * task4 attempts GR(gid=1) -- should be granted
273  * task0,4 writes to file and releases GR(gid=1) --
274  *       this allows task2 & 3's GR locks to be granted; task4 remains blocked.
275  * task1 & 3 write to file and release GR(gid=2)
276  * task2 PR|PW should be granted and reads the file.
277  */
278 void grouplock_test2(char *filename, int fd, int blocking_op, int unlock_op)
279 {
280         int i, iter, rc, gid = 1;
281         int flag1, flag2, flag3, flag4;
282         int temp1, temp2, temp3, temp4;
283         MPI_Request req1, req2, req3, req4;
284
285         if (rank == 0) {
286                 if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) {
287                         sprintf(errmsg,
288                                 "ioctl GROUP_LOCK of file %s: (%d) %s.\n",
289                                 filename, errno, strerror(errno));
290                         FAIL(errmsg);
291                 }
292         }
293
294         MPI_Barrier(MPI_COMM_WORLD);
295
296         switch (rank) {
297         case 3:
298                 /* Wait for task2 to issue its read request. */
299                 sleep(2*WAIT_TIME);
300         case 1:
301                 gid = 2;
302                 if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) {
303                         sprintf(errmsg,
304                                 "ioctl GROUP_LOCK of file %s: (%d) %s.\n",
305                                 filename, errno, strerror(errno));
306                         FAIL(errmsg);
307                 }
308
309                 write_buf(fd, rank);
310
311                 MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD);
312
313                 /* Do not release the locks until task 0 is ready to watch
314                    for reading task only */
315                 MPI_Recv(&temp1, 1, MPI_INT, 0, 1, MPI_COMM_WORLD,
316                          MPI_STATUS_IGNORE);
317
318                 if (unlock_op == CLOSE)
319                         rc = close(fd);
320                 else
321                         rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid);
322                 if (rc == -1) {
323                         sprintf(errmsg,
324                                 "%s release GROUP_LOCK of file %s: (%d) %s.\n",
325                                 (unlock_op == CLOSE) ? "close" : "ioctl",
326                                 filename, errno, strerror(errno));
327                         FAIL(errmsg);
328                 }
329                 break;
330         case 2:
331                 /* Give task1 a chance to request its GR lock. */
332                 sleep(WAIT_TIME);
333
334                 if (blocking_op == WRITE) {
335                         write_buf(fd, rank);
336                         lseek(fd, 0, SEEK_SET);
337                 }
338
339                 for (i = 0; i <= 3; i++)
340                         read_buf(fd);
341
342                 MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD);
343                 break;
344         case 4:
345                 /* Give task1 & 3 a chance to queue their GR locks. */
346                 sleep(3*WAIT_TIME);
347
348                 if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) {
349                         sprintf(errmsg,
350                                 "ioctl GROUP_LOCK of file %s: (%d) %s.\n",
351                                 filename, errno, strerror(errno));
352                         FAIL(errmsg);
353                 }
354
355                 write_buf(fd, rank);
356
357                 rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid);
358                 if (rc == -1) {
359                         sprintf(errmsg,
360                                 "%s release GROUP_LOCK of file %s: (%d) %s.\n",
361                                 (unlock_op == CLOSE) ? "close" : "ioctl",
362                                 filename, errno, strerror(errno));
363                         FAIL(errmsg);
364                 }
365
366                 MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD);
367                 break;
368         case 0:
369                 /* locking tasks will tell us when they complete */
370                 MPI_Irecv(&temp1, 1, MPI_INT, 1, 1, MPI_COMM_WORLD, &req1);
371                 MPI_Irecv(&temp2, 1, MPI_INT, 2, 1, MPI_COMM_WORLD, &req2);
372                 MPI_Irecv(&temp3, 1, MPI_INT, 3, 1, MPI_COMM_WORLD, &req3);
373                 MPI_Irecv(&temp4, 1, MPI_INT, 4, 1, MPI_COMM_WORLD, &req4);
374
375                 /* Make sure all tasks that should be blocked are waiting. */
376                 iter = MAX_WAIT_TRIES;
377                 do {
378                         iter--;
379                         sleep(WAIT_TIME);
380                         MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE);
381                         MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE);
382                         MPI_Test(&req3, &flag3, MPI_STATUS_IGNORE);
383                         if (flag1 || flag3) {
384                                 FAIL("GROUP (gid=2) task progressed even though"
385                                      " GROUP (gid=1) lock is held.\n");
386                         }
387                         if (flag2) {
388                                 FAIL("PR|PW task progressed even though "
389                                      "GROUP (gid=1) lock is still held\n");
390                         }
391                 } while (iter);
392
393                 /* Wait for task4 to signal it has completed. */
394                 iter = MAX_WAIT_TRIES;
395                 do {
396                         iter--;
397                         if (!iter) {
398                                 FAIL("2nd task GROUP(gid=1) not progressing\n");
399                         }
400                         sleep(WAIT_TIME);
401                         MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE);
402                         MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE);
403                         MPI_Test(&req3, &flag3, MPI_STATUS_IGNORE);
404                         MPI_Test(&req4, &flag4, MPI_STATUS_IGNORE);
405                         if (flag1 || flag3) {
406                                 FAIL("GROUP (gid=2) task progressed even though"
407                                      " GROUP (gid=1) lock is held.\n");
408                         }
409                         if (flag2) {
410                                 FAIL("PR|PW task progressed even though "
411                                      "GROUP (gid=1) lock is still held\n");
412                         }
413                 } while (!flag4);
414
415                 write_buf(fd, rank);
416
417                 /* Now let's release first lock */
418                 if ((rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid)) == -1) {
419                         sprintf(errmsg, "ioctl GROUP_UNLOCK of file %s "
420                                 "returned %d", filename, rc);
421                         FAIL(errmsg);
422                 }
423
424                 /* Wait for task1 & 3 to signal they have their lock. */
425                 iter = MAX_WAIT_TRIES;
426                 do {
427                         iter--;
428                         if (!iter) {
429                                 FAIL("GROUP(gid=2) tasks not progressing\n");
430                         }
431                         sleep(WAIT_TIME);
432                         MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE);
433                         MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE);
434                         MPI_Test(&req3, &flag3, MPI_STATUS_IGNORE);
435                         if (flag2) {
436                                 fprintf(stderr, "task2 %d\n", flag2);
437                                 FAIL("PR task progressed even though GROUP lock"
438                                      " was on the queue task\n");
439                         }
440                 } while (!(flag1 && flag3));
441
442                 /* Make sure task2 is still waiting. */
443                 iter = MAX_WAIT_TRIES;
444                 do {
445                         iter--;
446                         sleep(WAIT_TIME);
447                         MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE);
448                         if (flag2) {
449                                 FAIL("PR task progressed even though GR(gid=2) "
450                                      "lock was active.\n");
451                         }
452                 } while (iter);
453
454                 /* Tell task1 & 3 to release their GR(gid=2) lock. */
455                 MPI_Send(&gid, 1, MPI_INT, 1, 1, MPI_COMM_WORLD);
456                 MPI_Send(&gid, 1, MPI_INT, 3, 1, MPI_COMM_WORLD);
457
458                 /* Wait for task2 (PR) to complete. */
459                 iter = MAX_WAIT_TRIES;
460                 do {
461                         iter--;
462                         if (!iter) {
463                                 FAIL("reading task is not progressing even "
464                                      "though GROUP locks are released\n");
465                                 break;
466                         }
467                         sleep(WAIT_TIME);
468                         MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE);
469                 } while (!flag3);
470                 break;
471         }
472 }
473
474 /*
475  * Tests a bug that once existed in the group lock code;
476  * i.e. that a GR lock request on a O_NONBLOCK fd could fail even though
477  * there is no blocking GROUP lock ahead of it on the waitq.
478  *
479  * task0 starts a large write (PW). this test could be racey if this
480  *       write finishes too quickly.
481  * task1 attempts GR(gid=1) -- blocked
482  * task2 attempts GR(gid=2) with a O_NONBLOCK fs. should not fail.
483  */
484 void grouplock_test3(char *filename, int fd)
485 {
486         MPI_Request req1, req2;
487         int iter, flag1, flag2, temp1, temp2;
488         int rc, gid = 1;
489
490         if (rank == 0) {
491                 alloc_lgbuf();
492         } else if (rank == 2) {
493                 rc = fcntl(fd, F_SETFL, O_NONBLOCK);
494                 if (rc == -1) {
495                         sprintf(errmsg, "fcntl(O_NONBLOCK) failed: (%d) %s.\n",
496                                 errno, strerror(errno));
497                         FAIL(errmsg);
498                 }
499         }
500
501         MPI_Barrier(MPI_COMM_WORLD);
502
503         switch (rank) {
504         case 2:
505                 gid = 2;
506                 usleep(10000);
507                 usleep(10000);
508         case 1:
509                 /* Racey, we have to sleep just long enough for
510                  * task0's write to start. */
511                 usleep(10000);
512
513                 if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) {
514                         sprintf(errmsg,
515                                 "ioctl GROUP_LOCK of file %s: (%d) %s.\n",
516                                 filename, errno, strerror(errno));
517                         FAIL(errmsg);
518                 }
519
520                 /* tell task0 we have the lock. */
521                 MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD);
522
523                 /* the close of fd will release the lock. */
524                 break;
525         case 0:
526                 rc = write(fd, lgbuf, lgbuf_size);
527                 if (rc == -1) {
528                         sprintf(errmsg, "write of file %s for %d bytes "
529                                 "returned %d: (%d) %s.\n",
530                                 filename, lgbuf_size,
531                                 rc, errno, strerror(errno));
532                         FAIL(errmsg);
533                 } else if (rc != lgbuf_size) {
534                         sprintf(errmsg, "write of file %s for %d bytes "
535                                 "returned %d.\n",
536                                 filename, lgbuf_size, rc);
537                         FAIL(errmsg);
538                 }
539
540                 /* GR tasks will tell us when they complete */
541                 MPI_Irecv(&temp1, 1, MPI_INT, 1, 1, MPI_COMM_WORLD, &req1);
542                 MPI_Irecv(&temp2, 1, MPI_INT, 2, 1, MPI_COMM_WORLD, &req2);
543
544                 /* Wait for task1 & 2 to complete. */
545                 iter = MAX_WAIT_TRIES;
546                 do {
547                         iter--;
548                         if (!iter) {
549                                 FAIL("GR(gid=1) tasks are not progressing even "
550                                      "no conflicting locks exist.\n");
551                                 break;
552                         }
553                         sleep(WAIT_TIME);
554                         MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE);
555                         MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE);
556                 } while (!(flag1 && flag2));
557                 break;
558         }
559 }
560
561 /*
562  * Tests a bug that once existed in the group lock code;
563  * i.e. extent locks without O_NONBLOCK that go on the waitq before a group
564  * lock request came in and was granted. The extent lock would timed out and
565  * produce an error.
566  *
567  * task0 starts a large write (PW). this test could be racey if this
568  *       write finishes too quickly.
569  * task1 attempts PR -- blocked
570  * task2 attempts GR(gid=1) -- blocked
571  * task0 completes write
572  * task1 should wakeup and complete its read
573  * task2 should wakeup and after task1 complete.
574  */
575 void grouplock_test4(char *filename, int fd)
576 {
577         MPI_Request req1;
578         int iter, flag1, temp1;
579         int rc, gid = 1;
580
581         if (rank == 0)
582                 alloc_lgbuf();
583
584         MPI_Barrier(MPI_COMM_WORLD);
585
586         switch (rank) {
587         case 1:
588                 /* Racey, we have to sleep just long enough for
589                  * task0's write to start. */
590                 MPI_Recv(&temp1, 1, MPI_INT, 0, 1, MPI_COMM_WORLD,
591                          MPI_STATUS_IGNORE);
592                 usleep(10000);
593                 usleep(10000);
594
595                 /* tell task2 to go. */
596                 MPI_Send(&gid, 1, MPI_INT, 2, 1, MPI_COMM_WORLD);
597
598
599                 read_buf(fd);
600                 MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD);
601                 break;
602         case 2:
603                 /* Give task0 & 1 a chance to start. */
604                 MPI_Recv(&temp1, 1, MPI_INT, 1, 1, MPI_COMM_WORLD,
605                          MPI_STATUS_IGNORE);
606                 usleep(25000);
607                 usleep(25000);
608
609                 if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) {
610                         sprintf(errmsg,
611                                 "ioctl GROUP_LOCK of file %s: (%d) %s.\n",
612                                 filename, errno, strerror(errno));
613                         FAIL(errmsg);
614                 }
615
616                 /* tell task0 we have the lock. */
617                 MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD);
618
619                 /* Do not release the locks until task 0 tells us too.
620                    for reading task only */
621                 MPI_Recv(&temp1, 1, MPI_INT, 0, 1, MPI_COMM_WORLD,
622                          MPI_STATUS_IGNORE);
623
624                 rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid);
625                 if (rc == -1) {
626                         sprintf(errmsg,
627                                 "ioctl GROUP_UNLOCK of file %s: (%d) %s.\n",
628                                 filename, errno, strerror(errno));
629                         FAIL(errmsg);
630                 }
631                 break;
632         case 0:
633                 /* tell task1 to go to avoid race */
634                 MPI_Send(&gid, 1, MPI_INT, 1, 1, MPI_COMM_WORLD);
635                 rc = write(fd, lgbuf, lgbuf_size);
636                 if (rc == -1) {
637                         sprintf(errmsg, "write of file %s for %d bytes "
638                                 "returned %d: (%d) %s.\n",
639                                 filename, lgbuf_size,
640                                 rc, errno, strerror(errno));
641                         FAIL(errmsg);
642                 } else if (rc != lgbuf_size) {
643                         sprintf(errmsg, "write of file %s for %d bytes "
644                                 "returned %d.\n",
645                                 filename, lgbuf_size, rc);
646                         FAIL(errmsg);
647                 }
648
649                 /* wait for task2 to get its lock. */
650                 MPI_Recv(&temp1, 1, MPI_INT, 2, 1, MPI_COMM_WORLD,
651                          MPI_STATUS_IGNORE);
652
653                 /* Tell task2 it's ok to release its GR(gid=1) lock. */
654                 MPI_Send(&gid, 1, MPI_INT, 2, 1, MPI_COMM_WORLD);
655
656                 /* wait a really long time. */
657                 sleep(180 * WAIT_TIME);
658
659                 /* PR task will tell us when it completes */
660                 MPI_Irecv(&temp1, 1, MPI_INT, 1, 1, MPI_COMM_WORLD, &req1);
661
662                 /* Make sure the PR task is successful and doesn't hang.
663                  *
664                  * XXX - To test properly we need to make sure the read
665                  *       gets queued before task2's group lock request.
666                  *       You may need to increase lgbuf_size.
667                  */
668                 iter = MAX_WAIT_TRIES;
669                 do {
670                         iter--;
671                         if (!iter) {
672                                 FAIL("PR task is hung !\n");
673                                 break;
674                         }
675                         sleep(WAIT_TIME);
676                         MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE);
677                 } while (!flag1);
678
679                 break;
680         }
681 }
682
683 /*
684  * task0 attempts GR(gid=1) -- granted
685  * task1 attempts PR on non-blocking fd -> should return -EWOULDBLOCK
686  * task2 attempts PW on non-blocking fd -> should return -EWOULDBLOCK
687  * task3 attempts GR(gid=2) on non-blocking fd -> should return -EWOULDBLOCK
688  */
689 void grouplock_nonblock_test(char *filename, int fd)
690 {
691         MPI_Request req1, req2, req3;
692         int iter, flag1, flag2, flag3, temp1, temp2, temp3;
693         int rc, gid = 1;
694
695         if (rank == 0) {
696                 if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) {
697                         sprintf(errmsg,
698                                 "ioctl GROUP_LOCK of file %s: (%d) %s.\n",
699                                 filename, errno, strerror(errno));
700                         FAIL(errmsg);
701                 }
702         }
703
704         rc = fcntl(fd, F_SETFL, O_NONBLOCK);
705         if (rc == -1) {
706                 sprintf(errmsg, "fcntl(O_NONBLOCK) failed: (%d) %s.\n",
707                         errno, strerror(errno));
708                 FAIL(errmsg);
709         }
710
711         MPI_Barrier(MPI_COMM_WORLD);
712
713         switch (rank) {
714         case 1:
715                 rc = read(fd, buf, sizeof(buf));
716                 if ((rc != -1) || (errno != EWOULDBLOCK)) {
717                         FAIL("PR lock succeeded while incompatible "
718                              "GROUP LOCK (gid=1) is still held\n");
719                 }
720
721                 MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD);
722                 break;
723         case 2:
724                 rc = write(fd, buf, sizeof(buf));
725                 if ((rc != -1) || (errno != EWOULDBLOCK)) {
726                         FAIL("PW lock succeeded while incompatible "
727                              "GROUP LOCK (gid=1) is still held\n");
728                 }
729
730                 MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD);
731                 break;
732         case 3:
733                 gid = 2;
734                 rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid);
735                 if ((rc != -1) || (errno != EWOULDBLOCK)) {
736                         FAIL("GROUP_LOCK (gid=2) succeeded while incompatible "
737                              "GROUP LOCK (gid=1) is still held.\n");
738                 }
739
740                 MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD);
741                 break;
742         case 0:
743                 /* reading task will tell us when it completes */
744                 MPI_Irecv(&temp1, 1, MPI_INT, 1, 1, MPI_COMM_WORLD, &req1);
745                 /* writing task will tell us when it completes */
746                 MPI_Irecv(&temp2, 1, MPI_INT, 2, 1, MPI_COMM_WORLD, &req2);
747                 /* 2nd locking task will tell us when it completes */
748                 MPI_Irecv(&temp3, 1, MPI_INT, 3, 1, MPI_COMM_WORLD, &req3);
749
750                 iter = MAX_WAIT_TRIES;
751                 do {
752                         iter--;
753                         if (!iter) {
754                                 FAIL("non-blocking tasks are not progressing\n");
755                         }
756                         sleep(WAIT_TIME);
757                         MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE);
758                         MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE);
759                         MPI_Test(&req3, &flag3, MPI_STATUS_IGNORE);
760                 } while (!(flag1 && flag2 && flag3));
761
762                 if ((rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid)) == -1) {
763                         sprintf(errmsg, "ioctl GROUP_UNLOCK of file %s",
764                                 filename);
765                         FAIL(errmsg);
766                 }
767                 break;
768         }
769 }
770
771 /* Just test some error paths with invalid requests */
772 void grouplock_errorstest(char *filename, int fd)
773 {
774         int rc, gid = 1;
775
776         MPI_Barrier(MPI_COMM_WORLD);
777
778         switch (rank) {
779         case 0:
780                 if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) {
781                         sprintf(errmsg,
782                                 "ioctl GROUP_LOCK of file %s: (%d) %s.\n",
783                                 filename, errno, strerror(errno));
784                         FAIL(errmsg);
785                 }
786
787                 /* second group lock on same fd, same gid */
788                 if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) {
789                         if (errno != EINVAL) {
790                                 sprintf(errmsg, "Double GROUP lock failed "
791                                         "with errno %d instead of EINVAL\n",
792                                         errno);
793                                 FAIL(errmsg);
794                         }
795                 } else {
796                         FAIL("Taking second GROUP lock on same fd succeed\n");
797                 }
798
799                 /* second group lock on same fd, different gid */
800                 if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid + 1)) == -1) {
801                         if (errno != EINVAL) {
802                                 sprintf(errmsg, "Double GROUP lock with "
803                                         "different gid failed with errno %d "
804                                         "instead of EINVAL\n", errno);
805                                 FAIL(errmsg);
806                         }
807                 } else {
808                         FAIL("Taking second GROUP lock on same fd, with "
809                              "different gid, succeeded.\n");
810                 }
811
812                 /* GROUP unlock with wrong gid */
813                 if ((rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid + 1)) == -1) {
814                         if (errno != EINVAL) {
815                                 sprintf(errmsg, "GROUP_UNLOCK with wrong gid "
816                                         "failed with errno %d instead of "
817                                         "EINVAL\n", errno);
818                                 FAIL(errmsg);
819                         }
820                 } else {
821                         FAIL("GROUP unlock with wrong gid succeed\n");
822                 }
823
824                 if ((rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid)) == -1) {
825                         sprintf(errmsg, "ioctl GROUP_UNLOCK of file %s "
826                                 "returned %d.", filename, rc);
827                         FAIL(errmsg);
828                 }
829                 break;
830
831         case 1:
832                 /* unlock of never locked fd */
833                 if ((rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid)) == -1) {
834                         if (errno != EINVAL) {
835                                 sprintf(errmsg, "GROUP_UNLOCK on never locked "
836                                         "fd failed with errno %d instead of "
837                                         "EINVAL.\n", errno);
838                                 FAIL(errmsg);
839                         }
840                 } else {
841                         FAIL("GROUP unlock on never locked fd succeed\n");
842                 }
843                 break;
844         }
845 }
846
847 void grouplock_file(char *name, int subtest)
848 {
849         int fd;
850         int flags = O_CREAT|O_RDWR|O_SYNC|O_TRUNC;
851         int mode = 0666;
852
853         sprintf(filename, "%s/%s", testdir, name);
854
855         if ((fd = open(filename, flags, mode)) == -1) {
856                 sprintf(errmsg, "open of file %s: (%d) %s.\n",
857                         filename, errno, strerror(errno));
858                 FAIL(errmsg);
859         }
860
861         MPI_Barrier(MPI_COMM_WORLD);
862
863         switch (subtest) {
864         case 1:
865                 grouplock_test1(filename, fd, READ, IOCTL);
866                 break;
867         case 2:
868                 grouplock_test1(filename, fd, READ, CLOSE);
869                 break;
870         case 3:
871                 grouplock_test1(filename, fd, WRITE, IOCTL);
872                 break;
873         case 4:
874                 grouplock_test1(filename, fd, WRITE, CLOSE);
875                 break;
876         case 5:
877                 grouplock_test2(filename, fd, READ, IOCTL);
878                 break;
879         case 6:
880                 grouplock_test2(filename, fd, READ, CLOSE);
881                 break;
882         case 7:
883                 grouplock_test2(filename, fd, WRITE, IOCTL);
884                 break;
885         case 8:
886                 grouplock_test2(filename, fd, WRITE, CLOSE);
887                 break;
888         case 9:
889                 grouplock_nonblock_test(filename, fd);
890                 break;
891         case 10:
892                 grouplock_errorstest(filename, fd);
893                 break;
894         case 11:
895                 grouplock_test3(filename, fd);
896                 break;
897         case 12:
898                 grouplock_test4(filename, fd);
899                 break;
900         default:
901                 sprintf(errmsg, "wrong subtest number %d (should be <= %d)",
902                         subtest, LPGL_TEST_ITEMS);
903                 FAIL(errmsg);
904         }
905
906         close(fd);
907
908         if (rank == 0)
909                 unlink(filename);
910
911         MPI_Barrier(MPI_COMM_WORLD);
912 }
913
914 void parallel_grouplock(void)
915 {
916         char teststr[16];
917         int i;
918
919         if (only_test) {
920                 sprintf(teststr, "subtest %d", only_test);
921                 begin(teststr);
922                 grouplock_file("parallel_grouplock", only_test);
923                 end(teststr);
924         } else {
925                 for (i = 1; i <= LPGL_TEST_ITEMS; i++) {
926                         sprintf(teststr, "subtest %d", i);
927                         begin(teststr);
928                         grouplock_file("parallel_grouplock", i);
929                         end(teststr);
930                 }
931         }
932 }
933
934 void usage(char *proc)
935 {
936         int i;
937
938         if (rank == 0) {
939                 printf("Usage: %s [-h] -d <testdir> [-n <num>]\n", proc);
940                 printf("           [-t <num>] [-v] [-V #] [-g]\n");
941                 printf("\t-h: prints this help message\n");
942                 printf("\t-d: the directory in which the tests will run\n");
943                 printf("\t-n: repeat test # times\n");
944                 printf("\t-t: run a particular test #\n");
945                 printf("\t-v: increase the verbositly level by 1\n");
946                 printf("\t-V: select a specific verbosity level\n");
947                 printf("\t-g: debug mode\n");
948         }
949
950         MPI_Initialized(&i);
951         if (i) MPI_Finalize();
952         exit(0);
953 }
954
955 int main(int argc, char *argv[])
956 {
957         int i, iterations = 1, c;
958
959         setbuf(stdout, 0);
960         setbuf(stderr, 0);
961
962         /* Check for -h parameter before MPI_Init so the binary can be
963            called directly, without, for instance, mpirun */
964         for (i = 1; i < argc; ++i) {
965                 if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help"))
966                         usage(argv[0]);
967         }
968
969         MPI_Init(&argc, &argv);
970         MPI_Comm_rank(MPI_COMM_WORLD, &rank);
971         MPI_Comm_size(MPI_COMM_WORLD, &size);
972
973         /* Parse command line options */
974         while (1) {
975                 c = getopt(argc, argv, "d:ghn:t:vV:");
976                 if (c == -1)
977                         break;
978
979                 switch (c) {
980                 case 'd':
981                         testdir = optarg;
982                         break;
983                 case 'g':
984                         debug = 1;
985                         break;
986                 case 'h':
987                         usage(argv[0]);
988                         break;
989                 case 'n':
990                         iterations = atoi(optarg);
991                         break;
992                 case 't':
993                         only_test = atoi(optarg);
994                         break;
995                 case 'v':
996                         verbose += 1;
997                         break;
998                 case 'V':
999                         verbose = atoi(optarg);
1000                         break;
1001                 }
1002         }
1003
1004         if (rank == 0)
1005                 printf("%s is running with %d task(es) %s\n",
1006                        argv[0], size, debug ? "in DEBUG mode" : "\b\b");
1007
1008         if (size < MIN_GLHOST) {
1009                 fprintf(stderr, "Error: "
1010                         "%d tasks run, but should be at least %d tasks to run "
1011                         "the test!\n", size, MIN_GLHOST);
1012                 MPI_Abort(MPI_COMM_WORLD, 2);
1013         }
1014
1015         if (testdir == NULL && rank == 0) {
1016                 fprintf(stderr, "Please specify a test directory! "
1017                         "(\"%s -h\" for help)\n",
1018                        argv[0]);
1019                 MPI_Abort(MPI_COMM_WORLD, 2);
1020         }
1021
1022         lp_gethostname();
1023
1024         for (i = 0; i < iterations; ++i) {
1025                 if (rank == 0)
1026                         printf("%s: Running test #%s(iter %d)\n",
1027                                timestamp(), argv[0], i);
1028
1029                 parallel_grouplock();
1030                 MPI_Barrier(MPI_COMM_WORLD);
1031         }
1032
1033         if (rank == 0) {
1034                 printf("%s: All tests passed!\n", timestamp());
1035         }
1036         MPI_Finalize();
1037         return 0;
1038 }