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