From: Arshad Hussain Date: Sat, 6 Jul 2019 01:29:21 +0000 (+0530) Subject: LU-6142 tests: Fix style issues for parallel_grouplock.c X-Git-Tag: 2.12.57~32 X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=commitdiff_plain;h=2cf82b6f666cb2ed4484e8675bea1f2df43fc56e LU-6142 tests: Fix style issues for parallel_grouplock.c This patch fixes issues reported by checkpatch for file lustre/tests/mpi/parallel_grouplock.c Test-Parameters: trivial Signed-off-by: Arshad Hussain Change-Id: I746b77db6fe27ee7b9306014f57887ee7504baf3 Reviewed-on: https://review.whamcloud.com/35436 Tested-by: jenkins Tested-by: Maloo Reviewed-by: Andreas Dilger Reviewed-by: James Simmons --- diff --git a/lustre/tests/mpi/parallel_grouplock.c b/lustre/tests/mpi/parallel_grouplock.c index 9cf2464..16480e7 100644 --- a/lustre/tests/mpi/parallel_grouplock.c +++ b/lustre/tests/mpi/parallel_grouplock.c @@ -64,74 +64,73 @@ #define IOCTL 3 #define CLOSE 4 -int rank = 0; -int size = 0; +int rank; +int size; -char *testdir = NULL; -int only_test; +char *testdir; +int only_test; -char buf[LPGL_BUF_LEN]; +char buf[LPGL_BUF_LEN]; char *lgbuf; -int lgbuf_size; -char filename[MAX_FILENAME_LEN]; -char errmsg[MAX_FILENAME_LEN+96]; +int lgbuf_size; +char filename[MAX_FILENAME_LEN]; +char errmsg[MAX_FILENAME_LEN + 96]; static void alloc_lgbuf() { + if (lgbuf) + return; - if (lgbuf) - return; + lgbuf_size = MAX_LGBUF_SIZE; + for (; lgbuf_size >= MIN_LGBUF_SIZE; lgbuf_size -= ONE_MB) + if ((lgbuf = (char *)malloc(lgbuf_size)) != NULL) + return; - lgbuf_size = MAX_LGBUF_SIZE; - for (; lgbuf_size >= MIN_LGBUF_SIZE; lgbuf_size -= ONE_MB) - if ((lgbuf = (char *)malloc(lgbuf_size)) != NULL) - return; - - FAIL("malloc of large buffer failed.\n"); + FAIL("malloc of large buffer failed.\n"); } static inline void read_buf(int fd) { - int pos, rc; - - rc = read(fd, buf, sizeof(buf)); - if (rc == -1) { - pos = lseek(fd, 0, SEEK_CUR); - sprintf(errmsg, "read of file %s at pos %d for %zu bytes " - "returned %d: (%d) %s.\n", - filename, pos, sizeof(buf), rc, errno, strerror(errno)); - FAIL(errmsg); - } else if (rc != sizeof(buf)) { - pos = lseek(fd, 0, SEEK_CUR); - sprintf(errmsg, "read of file %s at pos %d for %zu bytes " - "returned %d.\n", - filename, pos, sizeof(buf), rc); - FAIL(errmsg); - } + int pos, rc; + + rc = read(fd, buf, sizeof(buf)); + if (rc == -1) { + pos = lseek(fd, 0, SEEK_CUR); + sprintf(errmsg, + "read of file %s at pos %d for %zu bytes returned %d: (%d) %s.\n", + filename, pos, sizeof(buf), rc, errno, strerror(errno)); + FAIL(errmsg); + } else if (rc != sizeof(buf)) { + pos = lseek(fd, 0, SEEK_CUR); + sprintf(errmsg, + "read of file %s at pos %d for %zu bytes returned %d.\n", + filename, pos, sizeof(buf), rc); + FAIL(errmsg); + } } static inline void write_buf(int fd, int index) { - int pos = index * sizeof(buf); - int rc; - - memset(buf, index, sizeof(buf)); - lseek(fd, pos, SEEK_SET); - rc = write(fd, buf, sizeof(buf)); - if (rc == -1) { - sprintf(errmsg, "write of file %s at pos %d for %zu bytes " - "returned %d: (%d) %s.\n", - filename, pos, sizeof(buf), rc, errno, strerror(errno)); - FAIL(errmsg); - } else if (rc != sizeof(buf)) { - sprintf(errmsg, "write of file %s at pos %d for %zu bytes " - "returned %d.\n", - filename, pos, sizeof(buf), rc); - FAIL(errmsg); - } + int pos = index * sizeof(buf); + int rc; + + memset(buf, index, sizeof(buf)); + lseek(fd, pos, SEEK_SET); + rc = write(fd, buf, sizeof(buf)); + if (rc == -1) { + sprintf(errmsg, + "write of file %s at pos %d for %zu bytes returned %d: (%d) %s.\n", + filename, pos, sizeof(buf), rc, errno, strerror(errno)); + FAIL(errmsg); + } else if (rc != sizeof(buf)) { + sprintf(errmsg, + "write of file %s at pos %d for %zu bytes returned %d.\n", + filename, pos, sizeof(buf), rc); + FAIL(errmsg); + } } /* @@ -145,122 +144,116 @@ write_buf(int fd, int index) */ void grouplock_test1(char *filename, int fd, int blocking_op, int unlock_op) { - MPI_Request req1, req2; - int iter, flag1, flag2, temp1, temp2; - int i, rc, gid = 1; - - if (rank == 0) { - if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) { - sprintf(errmsg, - "ioctl GROUP_LOCK of file %s: (%d) %s.\n", - filename, errno, strerror(errno)); - FAIL(errmsg); - } - } - - MPI_Barrier(MPI_COMM_WORLD); - - switch (rank) { - case 1: - if (blocking_op == WRITE) { - write_buf(fd, rank); - lseek(fd, 0, SEEK_SET); - } - - for (i = 0; i <= 2; i++) - read_buf(fd); - - MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); - break; - case 2: - /* Wait for task1 to progress. This could be racey. */ - sleep(WAIT_TIME); - - if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) { - sprintf(errmsg, - "ioctl GROUP_LOCK of file %s: (%d) %s.\n", - filename, errno, strerror(errno)); - FAIL(errmsg); - } - - write_buf(fd, rank); - - if (unlock_op == CLOSE) - rc = close(fd); - else - rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid); - - if (rc == -1) { - sprintf(errmsg, - "%s release GROUP_LOCK of file %s: (%d) %s.\n", - (unlock_op == CLOSE) ? "close" : "ioctl", - filename, errno, strerror(errno)); - FAIL(errmsg); - } - MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); - break; - case 0: - /* PR|PW task will tell us when it completes */ - MPI_Irecv(&temp1, 1, MPI_INT, 1, 1, MPI_COMM_WORLD, &req1); - /* 2nd locking task will tell us when it completes */ - MPI_Irecv(&temp2, 1, MPI_INT, 2, 1, MPI_COMM_WORLD, &req2); - - /* Wait for task2 to complete. */ - iter = MAX_WAIT_TRIES; - do { - iter--; - if (!iter) { - FAIL("2nd locking task is not progressing\n"); - } - - sleep(WAIT_TIME); - - MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE); - if (flag1) { - FAIL("PR|PW task progressed even though GROUP " - "lock is held\n"); - } - - MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE); - } while (!flag2); - - /* Make sure task1 is still waiting. */ - iter = MAX_WAIT_TRIES; - do { - iter--; - sleep(WAIT_TIME); - MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE); - if (flag1) { - FAIL("PR|PW task progressed even though " - "GROUP lock is held\n"); - } - } while (iter); - - write_buf(fd, rank); - - /* Now we need to release the lock */ - if ((rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid)) == -1) { - sprintf(errmsg, - "ioctl GROUP_UNLOCK of file %s: (%d) %s.\n", - filename, errno, strerror(errno)); - FAIL(errmsg); - } - - /* Wait for task1 to complete. */ - iter = MAX_WAIT_TRIES; - do { - iter--; - if (!iter) { - FAIL("PR|PW task is not progressing even " - "though GROUP lock was released\n"); - break; - } - sleep(WAIT_TIME); - MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE); - } while (!flag1); - - break; - } + MPI_Request req1, req2; + int iter, flag1, flag2, temp1, temp2; + int i, rc, gid = 1; + + if (rank == 0) { + if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) { + sprintf(errmsg, + "ioctl GROUP_LOCK of file %s: (%d) %s.\n", + filename, errno, strerror(errno)); + FAIL(errmsg); + } + } + + MPI_Barrier(MPI_COMM_WORLD); + + switch (rank) { + case 1: + if (blocking_op == WRITE) { + write_buf(fd, rank); + lseek(fd, 0, SEEK_SET); + } + + for (i = 0; i <= 2; i++) + read_buf(fd); + + MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); + break; + case 2: + /* Wait for task1 to progress. This could be racey. */ + sleep(WAIT_TIME); + + if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) { + sprintf(errmsg, + "ioctl GROUP_LOCK of file %s: (%d) %s.\n", + filename, errno, strerror(errno)); + FAIL(errmsg); + } + + write_buf(fd, rank); + + if (unlock_op == CLOSE) + rc = close(fd); + else + rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid); + + if (rc == -1) { + sprintf(errmsg, + "%s release GROUP_LOCK of file %s: (%d) %s.\n", + (unlock_op == CLOSE) ? "close" : "ioctl", + filename, errno, strerror(errno)); + FAIL(errmsg); + } + MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); + break; + case 0: + /* PR|PW task will tell us when it completes */ + MPI_Irecv(&temp1, 1, MPI_INT, 1, 1, MPI_COMM_WORLD, &req1); + /* 2nd locking task will tell us when it completes */ + MPI_Irecv(&temp2, 1, MPI_INT, 2, 1, MPI_COMM_WORLD, &req2); + + /* Wait for task2 to complete. */ + iter = MAX_WAIT_TRIES; + do { + iter--; + if (!iter) + FAIL("2nd locking task is not progressing\n"); + + sleep(WAIT_TIME); + + MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE); + if (flag1) + FAIL("PR|PW task progressed even though GROUP lock is held\n"); + + MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE); + } while (!flag2); + + /* Make sure task1 is still waiting. */ + iter = MAX_WAIT_TRIES; + do { + iter--; + sleep(WAIT_TIME); + MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE); + if (flag1) + FAIL("PR|PW task progressed even though GROUP lock is held\n"); + } while (iter); + + write_buf(fd, rank); + + /* Now we need to release the lock */ + if ((rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid)) == -1) { + sprintf(errmsg, + "ioctl GROUP_UNLOCK of file %s: (%d) %s.\n", + filename, errno, strerror(errno)); + FAIL(errmsg); + } + + /* Wait for task1 to complete. */ + iter = MAX_WAIT_TRIES; + do { + iter--; + if (!iter) { + FAIL("PR|PW task is not progressing even though GROUP lock was released\n"); + break; + } + sleep(WAIT_TIME); + MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE); + } while (!flag1); + + break; + } } /* @@ -276,198 +269,189 @@ void grouplock_test1(char *filename, int fd, int blocking_op, int unlock_op) */ void grouplock_test2(char *filename, int fd, int blocking_op, int unlock_op) { - int i, iter, rc, gid = 1; - int flag1, flag2, flag3, flag4; - int temp1, temp2, temp3, temp4; - MPI_Request req1, req2, req3, req4; - - if (rank == 0) { - if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) { - sprintf(errmsg, - "ioctl GROUP_LOCK of file %s: (%d) %s.\n", - filename, errno, strerror(errno)); - FAIL(errmsg); - } - } - - MPI_Barrier(MPI_COMM_WORLD); - - switch (rank) { - case 3: - /* Wait for task2 to issue its read request. */ - sleep(2*WAIT_TIME); - case 1: - gid = 2; - if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) { - sprintf(errmsg, - "ioctl GROUP_LOCK of file %s: (%d) %s.\n", - filename, errno, strerror(errno)); - FAIL(errmsg); - } - - write_buf(fd, rank); - - MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); - - /* Do not release the locks until task 0 is ready to watch - for reading task only */ - MPI_Recv(&temp1, 1, MPI_INT, 0, 1, MPI_COMM_WORLD, - MPI_STATUS_IGNORE); - - if (unlock_op == CLOSE) - rc = close(fd); - else - rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid); - if (rc == -1) { - sprintf(errmsg, - "%s release GROUP_LOCK of file %s: (%d) %s.\n", - (unlock_op == CLOSE) ? "close" : "ioctl", - filename, errno, strerror(errno)); - FAIL(errmsg); - } - break; - case 2: - /* Give task1 a chance to request its GR lock. */ - sleep(WAIT_TIME); - - if (blocking_op == WRITE) { - write_buf(fd, rank); - lseek(fd, 0, SEEK_SET); - } - - for (i = 0; i <= 3; i++) - read_buf(fd); - - MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); - break; - case 4: - /* Give task1 & 3 a chance to queue their GR locks. */ - sleep(3*WAIT_TIME); - - if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) { - sprintf(errmsg, - "ioctl GROUP_LOCK of file %s: (%d) %s.\n", - filename, errno, strerror(errno)); - FAIL(errmsg); - } - - write_buf(fd, rank); - - rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid); - if (rc == -1) { - sprintf(errmsg, - "%s release GROUP_LOCK of file %s: (%d) %s.\n", - (unlock_op == CLOSE) ? "close" : "ioctl", - filename, errno, strerror(errno)); - FAIL(errmsg); - } - - MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); - break; - case 0: - /* locking tasks will tell us when they complete */ - MPI_Irecv(&temp1, 1, MPI_INT, 1, 1, MPI_COMM_WORLD, &req1); - MPI_Irecv(&temp2, 1, MPI_INT, 2, 1, MPI_COMM_WORLD, &req2); - MPI_Irecv(&temp3, 1, MPI_INT, 3, 1, MPI_COMM_WORLD, &req3); - MPI_Irecv(&temp4, 1, MPI_INT, 4, 1, MPI_COMM_WORLD, &req4); - - /* Make sure all tasks that should be blocked are waiting. */ - iter = MAX_WAIT_TRIES; - do { - iter--; - sleep(WAIT_TIME); - MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE); - MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE); - MPI_Test(&req3, &flag3, MPI_STATUS_IGNORE); - if (flag1 || flag3) { - FAIL("GROUP (gid=2) task progressed even though" - " GROUP (gid=1) lock is held.\n"); - } - if (flag2) { - FAIL("PR|PW task progressed even though " - "GROUP (gid=1) lock is still held\n"); - } - } while (iter); - - /* Wait for task4 to signal it has completed. */ - iter = MAX_WAIT_TRIES; - do { - iter--; - if (!iter) { - FAIL("2nd task GROUP(gid=1) not progressing\n"); - } - sleep(WAIT_TIME); - MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE); - MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE); - MPI_Test(&req3, &flag3, MPI_STATUS_IGNORE); - MPI_Test(&req4, &flag4, MPI_STATUS_IGNORE); - if (flag1 || flag3) { - FAIL("GROUP (gid=2) task progressed even though" - " GROUP (gid=1) lock is held.\n"); - } - if (flag2) { - FAIL("PR|PW task progressed even though " - "GROUP (gid=1) lock is still held\n"); - } - } while (!flag4); - - write_buf(fd, rank); - - /* Now let's release first lock */ - if ((rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid)) == -1) { - sprintf(errmsg, "ioctl GROUP_UNLOCK of file %s " - "returned %d", filename, rc); - FAIL(errmsg); - } - - /* Wait for task1 & 3 to signal they have their lock. */ - iter = MAX_WAIT_TRIES; - do { - iter--; - if (!iter) { - FAIL("GROUP(gid=2) tasks not progressing\n"); - } - sleep(WAIT_TIME); - MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE); - MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE); - MPI_Test(&req3, &flag3, MPI_STATUS_IGNORE); - if (flag2) { - fprintf(stderr, "task2 %d\n", flag2); - FAIL("PR task progressed even though GROUP lock" - " was on the queue task\n"); - } - } while (!(flag1 && flag3)); - - /* Make sure task2 is still waiting. */ - iter = MAX_WAIT_TRIES; - do { - iter--; - sleep(WAIT_TIME); - MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE); - if (flag2) { - FAIL("PR task progressed even though GR(gid=2) " - "lock was active.\n"); - } - } while (iter); - - /* Tell task1 & 3 to release their GR(gid=2) lock. */ - MPI_Send(&gid, 1, MPI_INT, 1, 1, MPI_COMM_WORLD); - MPI_Send(&gid, 1, MPI_INT, 3, 1, MPI_COMM_WORLD); - - /* Wait for task2 (PR) to complete. */ - iter = MAX_WAIT_TRIES; - do { - iter--; - if (!iter) { - FAIL("reading task is not progressing even " - "though GROUP locks are released\n"); - break; - } - sleep(WAIT_TIME); - MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE); - } while (!flag3); - break; - } + int i, iter, rc, gid = 1; + int flag1, flag2, flag3, flag4; + int temp1, temp2, temp3, temp4; + MPI_Request req1, req2, req3, req4; + + if (rank == 0) { + if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) { + sprintf(errmsg, + "ioctl GROUP_LOCK of file %s: (%d) %s.\n", + filename, errno, strerror(errno)); + FAIL(errmsg); + } + } + + MPI_Barrier(MPI_COMM_WORLD); + + switch (rank) { + case 3: + /* Wait for task2 to issue its read request. */ + sleep(2 * WAIT_TIME); + case 1: + gid = 2; + if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) { + sprintf(errmsg, + "ioctl GROUP_LOCK of file %s: (%d) %s.\n", + filename, errno, strerror(errno)); + FAIL(errmsg); + } + + write_buf(fd, rank); + + MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); + + /* + * Do not release the locks until task 0 is ready to watch + * for reading task only + */ + MPI_Recv(&temp1, 1, MPI_INT, 0, 1, MPI_COMM_WORLD, + MPI_STATUS_IGNORE); + + if (unlock_op == CLOSE) + rc = close(fd); + else + rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid); + if (rc == -1) { + sprintf(errmsg, + "%s release GROUP_LOCK of file %s: (%d) %s.\n", + (unlock_op == CLOSE) ? "close" : "ioctl", + filename, errno, strerror(errno)); + FAIL(errmsg); + } + break; + case 2: + /* Give task1 a chance to request its GR lock. */ + sleep(WAIT_TIME); + + if (blocking_op == WRITE) { + write_buf(fd, rank); + lseek(fd, 0, SEEK_SET); + } + + for (i = 0; i <= 3; i++) + read_buf(fd); + + MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); + break; + case 4: + /* Give task1 & 3 a chance to queue their GR locks. */ + sleep(3 * WAIT_TIME); + + if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) { + sprintf(errmsg, + "ioctl GROUP_LOCK of file %s: (%d) %s.\n", + filename, errno, strerror(errno)); + FAIL(errmsg); + } + + write_buf(fd, rank); + + rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid); + if (rc == -1) { + sprintf(errmsg, + "%s release GROUP_LOCK of file %s: (%d) %s.\n", + (unlock_op == CLOSE) ? "close" : "ioctl", + filename, errno, strerror(errno)); + FAIL(errmsg); + } + + MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); + break; + case 0: + /* locking tasks will tell us when they complete */ + MPI_Irecv(&temp1, 1, MPI_INT, 1, 1, MPI_COMM_WORLD, &req1); + MPI_Irecv(&temp2, 1, MPI_INT, 2, 1, MPI_COMM_WORLD, &req2); + MPI_Irecv(&temp3, 1, MPI_INT, 3, 1, MPI_COMM_WORLD, &req3); + MPI_Irecv(&temp4, 1, MPI_INT, 4, 1, MPI_COMM_WORLD, &req4); + + /* Make sure all tasks that should be blocked are waiting. */ + iter = MAX_WAIT_TRIES; + do { + iter--; + sleep(WAIT_TIME); + MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE); + MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE); + MPI_Test(&req3, &flag3, MPI_STATUS_IGNORE); + if (flag1 || flag3) + FAIL("GROUP (gid=2) task progressed even though GROUP (gid=1) lock is held.\n"); + if (flag2) + FAIL("PR|PW task progressed even though GROUP (gid=1) lock is still held\n"); + } while (iter); + + /* Wait for task4 to signal it has completed. */ + iter = MAX_WAIT_TRIES; + do { + iter--; + if (!iter) + FAIL("2nd task GROUP(gid=1) not progressing\n"); + + sleep(WAIT_TIME); + MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE); + MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE); + MPI_Test(&req3, &flag3, MPI_STATUS_IGNORE); + MPI_Test(&req4, &flag4, MPI_STATUS_IGNORE); + if (flag1 || flag3) + FAIL("GROUP (gid=2) task progressed even though GROUP (gid=1) lock is held.\n"); + if (flag2) + FAIL("PR|PW task progressed even though GROUP (gid=1) lock is still held\n"); + } while (!flag4); + + write_buf(fd, rank); + + /* Now let's release first lock */ + if ((rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid)) == -1) { + sprintf(errmsg, + "ioctl GROUP_UNLOCK of file %s returned %d", + filename, rc); + FAIL(errmsg); + } + + /* Wait for task1 & 3 to signal they have their lock. */ + iter = MAX_WAIT_TRIES; + do { + iter--; + if (!iter) + FAIL("GROUP(gid=2) tasks not progressing\n"); + + sleep(WAIT_TIME); + MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE); + MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE); + MPI_Test(&req3, &flag3, MPI_STATUS_IGNORE); + if (flag2) { + fprintf(stderr, "task2 %d\n", flag2); + FAIL("PR task progressed even though GROUP lock was on the queue task\n"); + } + } while (!(flag1 && flag3)); + + /* Make sure task2 is still waiting. */ + iter = MAX_WAIT_TRIES; + do { + iter--; + sleep(WAIT_TIME); + MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE); + if (flag2) + FAIL("PR task progressed even though GR(gid=2) lock was active.\n"); + } while (iter); + + /* Tell task1 & 3 to release their GR(gid=2) lock. */ + MPI_Send(&gid, 1, MPI_INT, 1, 1, MPI_COMM_WORLD); + MPI_Send(&gid, 1, MPI_INT, 3, 1, MPI_COMM_WORLD); + + /* Wait for task2 (PR) to complete. */ + iter = MAX_WAIT_TRIES; + do { + iter--; + if (!iter) { + FAIL("reading task is not progressing even though GROUP locks are released\n"); + break; + } + sleep(WAIT_TIME); + MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE); + } while (!flag3); + break; + } } /* @@ -482,79 +466,80 @@ void grouplock_test2(char *filename, int fd, int blocking_op, int unlock_op) */ void grouplock_test3(char *filename, int fd) { - MPI_Request req1, req2; - int iter, flag1, flag2, temp1, temp2; - int rc, gid = 1; - - if (rank == 0) { - alloc_lgbuf(); - } else if (rank == 2) { - rc = fcntl(fd, F_SETFL, O_NONBLOCK); - if (rc == -1) { - sprintf(errmsg, "fcntl(O_NONBLOCK) failed: (%d) %s.\n", - errno, strerror(errno)); - FAIL(errmsg); - } - } - - MPI_Barrier(MPI_COMM_WORLD); - - switch (rank) { - case 2: - gid = 2; - usleep(10000); - usleep(10000); - case 1: - /* Racey, we have to sleep just long enough for - * task0's write to start. */ - usleep(10000); - - if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) { - sprintf(errmsg, - "ioctl GROUP_LOCK of file %s: (%d) %s.\n", - filename, errno, strerror(errno)); - FAIL(errmsg); - } - - /* tell task0 we have the lock. */ - MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); - - /* the close of fd will release the lock. */ - break; - case 0: - rc = write(fd, lgbuf, lgbuf_size); - if (rc == -1) { - sprintf(errmsg, "write of file %s for %d bytes " - "returned %d: (%d) %s.\n", - filename, lgbuf_size, - rc, errno, strerror(errno)); - FAIL(errmsg); - } else if (rc != lgbuf_size) { - sprintf(errmsg, "write of file %s for %d bytes " - "returned %d.\n", - filename, lgbuf_size, rc); - FAIL(errmsg); - } - - /* GR tasks will tell us when they complete */ - MPI_Irecv(&temp1, 1, MPI_INT, 1, 1, MPI_COMM_WORLD, &req1); - MPI_Irecv(&temp2, 1, MPI_INT, 2, 1, MPI_COMM_WORLD, &req2); - - /* Wait for task1 & 2 to complete. */ - iter = MAX_WAIT_TRIES; - do { - iter--; - if (!iter) { - FAIL("GR(gid=1) tasks are not progressing even " - "no conflicting locks exist.\n"); - break; - } - sleep(WAIT_TIME); - MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE); - MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE); - } while (!(flag1 && flag2)); - break; - } + MPI_Request req1, req2; + int iter, flag1, flag2, temp1, temp2; + int rc, gid = 1; + + if (rank == 0) { + alloc_lgbuf(); + } else if (rank == 2) { + rc = fcntl(fd, F_SETFL, O_NONBLOCK); + if (rc == -1) { + sprintf(errmsg, "fcntl(O_NONBLOCK) failed: (%d) %s.\n", + errno, strerror(errno)); + FAIL(errmsg); + } + } + + MPI_Barrier(MPI_COMM_WORLD); + + switch (rank) { + case 2: + gid = 2; + usleep(10000); + usleep(10000); + case 1: + /* + * Racey, we have to sleep just long enough for + * task0's write to start. + */ + usleep(10000); + + if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) { + sprintf(errmsg, + "ioctl GROUP_LOCK of file %s: (%d) %s.\n", + filename, errno, strerror(errno)); + FAIL(errmsg); + } + + /* tell task0 we have the lock. */ + MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); + + /* the close of fd will release the lock. */ + break; + case 0: + rc = write(fd, lgbuf, lgbuf_size); + if (rc == -1) { + sprintf(errmsg, + "write of file %s for %d bytes returned %d: (%d) %s.\n", + filename, lgbuf_size, + rc, errno, strerror(errno)); + FAIL(errmsg); + } else if (rc != lgbuf_size) { + sprintf(errmsg, + "write of file %s for %d bytes returned %d.\n", + filename, lgbuf_size, rc); + FAIL(errmsg); + } + + /* GR tasks will tell us when they complete */ + MPI_Irecv(&temp1, 1, MPI_INT, 1, 1, MPI_COMM_WORLD, &req1); + MPI_Irecv(&temp2, 1, MPI_INT, 2, 1, MPI_COMM_WORLD, &req2); + + /* Wait for task1 & 2 to complete. */ + iter = MAX_WAIT_TRIES; + do { + iter--; + if (!iter) { + FAIL("GR(gid=1) tasks are not progressing even no conflicting locks exist.\n"); + break; + } + sleep(WAIT_TIME); + MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE); + MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE); + } while (!(flag1 && flag2)); + break; + } } /* @@ -573,107 +558,112 @@ void grouplock_test3(char *filename, int fd) */ void grouplock_test4(char *filename, int fd) { - MPI_Request req1; - int iter, flag1, temp1; - int rc, gid = 1; - - if (rank == 0) - alloc_lgbuf(); - - MPI_Barrier(MPI_COMM_WORLD); - - switch (rank) { - case 1: - /* Racey, we have to sleep just long enough for - * task0's write to start. */ - MPI_Recv(&temp1, 1, MPI_INT, 0, 1, MPI_COMM_WORLD, - MPI_STATUS_IGNORE); - - /* tell task2 to go. */ - MPI_Send(&gid, 1, MPI_INT, 2, 1, MPI_COMM_WORLD); + MPI_Request req1; + int iter, flag1, temp1; + int rc, gid = 1; + + if (rank == 0) + alloc_lgbuf(); + + MPI_Barrier(MPI_COMM_WORLD); + + switch (rank) { + case 1: + /* + * Racey, we have to sleep just long enough for + * task0's write to start. + */ + MPI_Recv(&temp1, 1, MPI_INT, 0, 1, MPI_COMM_WORLD, + MPI_STATUS_IGNORE); + + /* tell task2 to go. */ + MPI_Send(&gid, 1, MPI_INT, 2, 1, MPI_COMM_WORLD); sleep(WAIT_TIME); - read_buf(fd); - MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); - break; - case 2: - /* Give task0 & 1 a chance to start. */ - MPI_Recv(&temp1, 1, MPI_INT, 1, 1, MPI_COMM_WORLD, - MPI_STATUS_IGNORE); + read_buf(fd); + MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); + break; + case 2: + /* Give task0 & 1 a chance to start. */ + MPI_Recv(&temp1, 1, MPI_INT, 1, 1, MPI_COMM_WORLD, + MPI_STATUS_IGNORE); sleep(2 * WAIT_TIME); - if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) { - sprintf(errmsg, - "ioctl GROUP_LOCK of file %s: (%d) %s.\n", - filename, errno, strerror(errno)); - FAIL(errmsg); - } - - /* tell task0 we have the lock. */ - MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); - - /* Do not release the locks until task 0 tells us too. - for reading task only */ - MPI_Recv(&temp1, 1, MPI_INT, 0, 1, MPI_COMM_WORLD, - MPI_STATUS_IGNORE); - - rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid); - if (rc == -1) { - sprintf(errmsg, - "ioctl GROUP_UNLOCK of file %s: (%d) %s.\n", - filename, errno, strerror(errno)); - FAIL(errmsg); - } - break; - case 0: - /* tell task1 to go to avoid race */ - MPI_Send(&gid, 1, MPI_INT, 1, 1, MPI_COMM_WORLD); - rc = write(fd, lgbuf, lgbuf_size); - if (rc == -1) { - sprintf(errmsg, "write of file %s for %d bytes " - "returned %d: (%d) %s.\n", - filename, lgbuf_size, - rc, errno, strerror(errno)); - FAIL(errmsg); - } else if (rc != lgbuf_size) { - sprintf(errmsg, "write of file %s for %d bytes " - "returned %d.\n", - filename, lgbuf_size, rc); - FAIL(errmsg); - } - - /* wait for task2 to get its lock. */ - MPI_Recv(&temp1, 1, MPI_INT, 2, 1, MPI_COMM_WORLD, - MPI_STATUS_IGNORE); - - /* Tell task2 it's ok to release its GR(gid=1) lock. */ - MPI_Send(&gid, 1, MPI_INT, 2, 1, MPI_COMM_WORLD); - - /* wait a really long time. */ - sleep(180 * WAIT_TIME); - - /* PR task will tell us when it completes */ - MPI_Irecv(&temp1, 1, MPI_INT, 1, 1, MPI_COMM_WORLD, &req1); - - /* Make sure the PR task is successful and doesn't hang. - * - * XXX - To test properly we need to make sure the read - * gets queued before task2's group lock request. - * You may need to increase lgbuf_size. - */ - iter = MAX_WAIT_TRIES; - do { - iter--; - if (!iter) { - FAIL("PR task is hung !\n"); - break; - } - sleep(WAIT_TIME); - MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE); - } while (!flag1); - - break; - } + if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) { + sprintf(errmsg, + "ioctl GROUP_LOCK of file %s: (%d) %s.\n", + filename, errno, strerror(errno)); + FAIL(errmsg); + } + + /* tell task0 we have the lock. */ + MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); + + /* + * Do not release the locks until task 0 tells us too. + * for reading task only + */ + MPI_Recv(&temp1, 1, MPI_INT, 0, 1, MPI_COMM_WORLD, + MPI_STATUS_IGNORE); + + rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid); + if (rc == -1) { + sprintf(errmsg, + "ioctl GROUP_UNLOCK of file %s: (%d) %s.\n", + filename, errno, strerror(errno)); + FAIL(errmsg); + } + break; + case 0: + /* tell task1 to go to avoid race */ + MPI_Send(&gid, 1, MPI_INT, 1, 1, MPI_COMM_WORLD); + rc = write(fd, lgbuf, lgbuf_size); + if (rc == -1) { + sprintf(errmsg, + "write of file %s for %d bytes returned %d: (%d) %s.\n", + filename, lgbuf_size, + rc, errno, strerror(errno)); + FAIL(errmsg); + } else if (rc != lgbuf_size) { + sprintf(errmsg, + "write of file %s for %d bytes returned %d.\n", + filename, lgbuf_size, rc); + FAIL(errmsg); + } + + /* wait for task2 to get its lock. */ + MPI_Recv(&temp1, 1, MPI_INT, 2, 1, MPI_COMM_WORLD, + MPI_STATUS_IGNORE); + + /* Tell task2 it's ok to release its GR(gid=1) lock. */ + MPI_Send(&gid, 1, MPI_INT, 2, 1, MPI_COMM_WORLD); + + /* wait a really long time. */ + sleep(180 * WAIT_TIME); + + /* PR task will tell us when it completes */ + MPI_Irecv(&temp1, 1, MPI_INT, 1, 1, MPI_COMM_WORLD, &req1); + + /* + * Make sure the PR task is successful and doesn't hang. + * + * XXX - To test properly we need to make sure the read + * gets queued before task2's group lock request. + * You may need to increase lgbuf_size. + */ + iter = MAX_WAIT_TRIES; + do { + iter--; + if (!iter) { + FAIL("PR task is hung !\n"); + break; + } + sleep(WAIT_TIME); + MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE); + } while (!flag1); + + break; + } } /* @@ -684,351 +674,348 @@ void grouplock_test4(char *filename, int fd) */ void grouplock_nonblock_test(char *filename, int fd) { - MPI_Request req1, req2, req3; - int iter, flag1, flag2, flag3, temp1, temp2, temp3; - int rc, gid = 1; - - if (rank == 0) { - if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) { - sprintf(errmsg, - "ioctl GROUP_LOCK of file %s: (%d) %s.\n", - filename, errno, strerror(errno)); - FAIL(errmsg); - } - } - - rc = fcntl(fd, F_SETFL, O_NONBLOCK); - if (rc == -1) { - sprintf(errmsg, "fcntl(O_NONBLOCK) failed: (%d) %s.\n", - errno, strerror(errno)); - FAIL(errmsg); - } - - MPI_Barrier(MPI_COMM_WORLD); - - switch (rank) { - case 1: - rc = read(fd, buf, sizeof(buf)); - if ((rc != -1) || (errno != EWOULDBLOCK)) { - FAIL("PR lock succeeded while incompatible " - "GROUP LOCK (gid=1) is still held\n"); - } - - MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); - break; - case 2: - rc = write(fd, buf, sizeof(buf)); - if ((rc != -1) || (errno != EWOULDBLOCK)) { - FAIL("PW lock succeeded while incompatible " - "GROUP LOCK (gid=1) is still held\n"); - } - - MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); - break; - case 3: - gid = 2; - rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid); - if ((rc != -1) || (errno != EWOULDBLOCK)) { - FAIL("GROUP_LOCK (gid=2) succeeded while incompatible " - "GROUP LOCK (gid=1) is still held.\n"); - } - - MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); - break; - case 0: - /* reading task will tell us when it completes */ - MPI_Irecv(&temp1, 1, MPI_INT, 1, 1, MPI_COMM_WORLD, &req1); - /* writing task will tell us when it completes */ - MPI_Irecv(&temp2, 1, MPI_INT, 2, 1, MPI_COMM_WORLD, &req2); - /* 2nd locking task will tell us when it completes */ - MPI_Irecv(&temp3, 1, MPI_INT, 3, 1, MPI_COMM_WORLD, &req3); - - iter = MAX_WAIT_TRIES; - do { - iter--; - if (!iter) { - FAIL("non-blocking tasks are not progressing\n"); - } - sleep(WAIT_TIME); - MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE); - MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE); - MPI_Test(&req3, &flag3, MPI_STATUS_IGNORE); - } while (!(flag1 && flag2 && flag3)); - - if ((rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid)) == -1) { - sprintf(errmsg, "ioctl GROUP_UNLOCK of file %s", - filename); - FAIL(errmsg); - } - break; - } + MPI_Request req1, req2, req3; + int iter, flag1, flag2, flag3, temp1, temp2, temp3; + int rc, gid = 1; + + if (rank == 0) { + if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) { + sprintf(errmsg, + "ioctl GROUP_LOCK of file %s: (%d) %s.\n", + filename, errno, strerror(errno)); + FAIL(errmsg); + } + } + + rc = fcntl(fd, F_SETFL, O_NONBLOCK); + if (rc == -1) { + sprintf(errmsg, "fcntl(O_NONBLOCK) failed: (%d) %s.\n", + errno, strerror(errno)); + FAIL(errmsg); + } + + MPI_Barrier(MPI_COMM_WORLD); + + switch (rank) { + case 1: + rc = read(fd, buf, sizeof(buf)); + if ((rc != -1) || (errno != EWOULDBLOCK)) + FAIL("PR lock succeeded while incompatible GROUP LOCK (gid=1) is still held\n"); + + MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); + break; + case 2: + rc = write(fd, buf, sizeof(buf)); + if ((rc != -1) || (errno != EWOULDBLOCK)) + FAIL("PW lock succeeded while incompatible GROUP LOCK (gid=1) is still held\n"); + + MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); + break; + case 3: + gid = 2; + rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid); + if ((rc != -1) || (errno != EWOULDBLOCK)) + FAIL("GROUP_LOCK (gid=2) succeeded while incompatible GROUP LOCK (gid=1) is still held.\n"); + + MPI_Send(&gid, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); + break; + case 0: + /* reading task will tell us when it completes */ + MPI_Irecv(&temp1, 1, MPI_INT, 1, 1, MPI_COMM_WORLD, &req1); + /* writing task will tell us when it completes */ + MPI_Irecv(&temp2, 1, MPI_INT, 2, 1, MPI_COMM_WORLD, &req2); + /* 2nd locking task will tell us when it completes */ + MPI_Irecv(&temp3, 1, MPI_INT, 3, 1, MPI_COMM_WORLD, &req3); + + iter = MAX_WAIT_TRIES; + do { + iter--; + if (!iter) + FAIL("non-blocking tasks are not progressing\n"); + + sleep(WAIT_TIME); + MPI_Test(&req1, &flag1, MPI_STATUS_IGNORE); + MPI_Test(&req2, &flag2, MPI_STATUS_IGNORE); + MPI_Test(&req3, &flag3, MPI_STATUS_IGNORE); + } while (!(flag1 && flag2 && flag3)); + + if ((rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid)) == -1) { + sprintf(errmsg, "ioctl GROUP_UNLOCK of file %s", + filename); + FAIL(errmsg); + } + break; + } } /* Just test some error paths with invalid requests */ void grouplock_errorstest(char *filename, int fd) { - int rc, gid = 1; - - MPI_Barrier(MPI_COMM_WORLD); - - switch (rank) { - case 0: - if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) { - sprintf(errmsg, - "ioctl GROUP_LOCK of file %s: (%d) %s.\n", - filename, errno, strerror(errno)); - FAIL(errmsg); - } - - /* second group lock on same fd, same gid */ - if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) { - if (errno != EINVAL) { - sprintf(errmsg, "Double GROUP lock failed " - "with errno %d instead of EINVAL\n", - errno); - FAIL(errmsg); - } - } else { - FAIL("Taking second GROUP lock on same fd succeed\n"); - } - - /* second group lock on same fd, different gid */ - if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid + 1)) == -1) { - if (errno != EINVAL) { - sprintf(errmsg, "Double GROUP lock with " - "different gid failed with errno %d " - "instead of EINVAL\n", errno); - FAIL(errmsg); - } - } else { - FAIL("Taking second GROUP lock on same fd, with " - "different gid, succeeded.\n"); - } - - /* GROUP unlock with wrong gid */ - if ((rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid + 1)) == -1) { - if (errno != EINVAL) { - sprintf(errmsg, "GROUP_UNLOCK with wrong gid " - "failed with errno %d instead of " - "EINVAL\n", errno); - FAIL(errmsg); - } - } else { - FAIL("GROUP unlock with wrong gid succeed\n"); - } - - if ((rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid)) == -1) { - sprintf(errmsg, "ioctl GROUP_UNLOCK of file %s " - "returned %d.", filename, rc); - FAIL(errmsg); - } - break; - - case 1: - /* unlock of never locked fd */ - if ((rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid)) == -1) { - if (errno != EINVAL) { - sprintf(errmsg, "GROUP_UNLOCK on never locked " - "fd failed with errno %d instead of " - "EINVAL.\n", errno); - FAIL(errmsg); - } - } else { - FAIL("GROUP unlock on never locked fd succeed\n"); - } - break; - } + int rc, gid = 1; + + MPI_Barrier(MPI_COMM_WORLD); + + switch (rank) { + case 0: + if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) { + sprintf(errmsg, + "ioctl GROUP_LOCK of file %s: (%d) %s.\n", + filename, errno, strerror(errno)); + FAIL(errmsg); + } + + /* second group lock on same fd, same gid */ + if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid)) == -1) { + if (errno != EINVAL) { + sprintf(errmsg, + "Double GROUP lock failed with errno %d instead of EINVAL\n", + errno); + FAIL(errmsg); + } + } else { + FAIL("Taking second GROUP lock on same fd succeed\n"); + } + + /* second group lock on same fd, different gid */ + if ((rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid + 1)) == -1) { + if (errno != EINVAL) { + sprintf(errmsg, + "Double GROUP lock with different gid failed with errno %d instead of EINVAL\n", + errno); + FAIL(errmsg); + } + } else { + FAIL("Taking second GROUP lock on same fd, with different gid, succeeded.\n"); + } + + /* GROUP unlock with wrong gid */ + if ((rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid + 1)) == -1) { + if (errno != EINVAL) { + sprintf(errmsg, + "GROUP_UNLOCK with wrong gid failed with errno %d instead of EINVAL\n", + errno); + FAIL(errmsg); + } + } else { + FAIL("GROUP unlock with wrong gid succeed\n"); + } + + if ((rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid)) == -1) { + sprintf(errmsg, + "ioctl GROUP_UNLOCK of file %s returned %d.", + filename, rc); + FAIL(errmsg); + } + break; + + case 1: + /* unlock of never locked fd */ + if ((rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid)) == -1) { + if (errno != EINVAL) { + sprintf(errmsg, + "GROUP_UNLOCK on never locked fd failed with errno %d instead of EINVAL.\n", + errno); + FAIL(errmsg); + } + } else { + FAIL("GROUP unlock on never locked fd succeed\n"); + } + break; + } } void grouplock_file(char *name, int subtest) { - int fd; - int flags = O_CREAT|O_RDWR|O_SYNC|O_TRUNC; - int mode = 0666; - - sprintf(filename, "%s/%s", testdir, name); - - if ((fd = open(filename, flags, mode)) == -1) { - sprintf(errmsg, "open of file %s: (%d) %s.\n", - filename, errno, strerror(errno)); - FAIL(errmsg); - } - - MPI_Barrier(MPI_COMM_WORLD); - - switch (subtest) { - case 1: - grouplock_test1(filename, fd, READ, IOCTL); - break; - case 2: - grouplock_test1(filename, fd, READ, CLOSE); - break; - case 3: - grouplock_test1(filename, fd, WRITE, IOCTL); - break; - case 4: - grouplock_test1(filename, fd, WRITE, CLOSE); - break; - case 5: - grouplock_test2(filename, fd, READ, IOCTL); - break; - case 6: - grouplock_test2(filename, fd, READ, CLOSE); - break; - case 7: - grouplock_test2(filename, fd, WRITE, IOCTL); - break; - case 8: - grouplock_test2(filename, fd, WRITE, CLOSE); - break; - case 9: - grouplock_nonblock_test(filename, fd); - break; - case 10: - grouplock_errorstest(filename, fd); - break; - case 11: - grouplock_test3(filename, fd); - break; - case 12: - grouplock_test4(filename, fd); - break; - default: - sprintf(errmsg, "wrong subtest number %d (should be <= %d)", - subtest, LPGL_TEST_ITEMS); - FAIL(errmsg); - } - - close(fd); - - if (rank == 0) - unlink(filename); - - MPI_Barrier(MPI_COMM_WORLD); + int fd; + int flags = O_CREAT | O_RDWR | O_SYNC | O_TRUNC; + int mode = 0666; + + sprintf(filename, "%s/%s", testdir, name); + + if ((fd = open(filename, flags, mode)) == -1) { + sprintf(errmsg, "open of file %s: (%d) %s.\n", + filename, errno, strerror(errno)); + FAIL(errmsg); + } + + MPI_Barrier(MPI_COMM_WORLD); + + switch (subtest) { + case 1: + grouplock_test1(filename, fd, READ, IOCTL); + break; + case 2: + grouplock_test1(filename, fd, READ, CLOSE); + break; + case 3: + grouplock_test1(filename, fd, WRITE, IOCTL); + break; + case 4: + grouplock_test1(filename, fd, WRITE, CLOSE); + break; + case 5: + grouplock_test2(filename, fd, READ, IOCTL); + break; + case 6: + grouplock_test2(filename, fd, READ, CLOSE); + break; + case 7: + grouplock_test2(filename, fd, WRITE, IOCTL); + break; + case 8: + grouplock_test2(filename, fd, WRITE, CLOSE); + break; + case 9: + grouplock_nonblock_test(filename, fd); + break; + case 10: + grouplock_errorstest(filename, fd); + break; + case 11: + grouplock_test3(filename, fd); + break; + case 12: + grouplock_test4(filename, fd); + break; + default: + sprintf(errmsg, "wrong subtest number %d (should be <= %d)", + subtest, LPGL_TEST_ITEMS); + FAIL(errmsg); + } + + close(fd); + + if (rank == 0) + unlink(filename); + + MPI_Barrier(MPI_COMM_WORLD); } void parallel_grouplock(void) { - char teststr[16]; - int i; - - if (only_test) { - sprintf(teststr, "subtest %d", only_test); - begin(teststr); - grouplock_file("parallel_grouplock", only_test); - end(teststr); - } else { - for (i = 1; i <= LPGL_TEST_ITEMS; i++) { - sprintf(teststr, "subtest %d", i); - begin(teststr); - grouplock_file("parallel_grouplock", i); - end(teststr); - } - } + char teststr[16]; + int i; + + if (only_test) { + sprintf(teststr, "subtest %d", only_test); + begin(teststr); + grouplock_file("parallel_grouplock", only_test); + end(teststr); + } else { + for (i = 1; i <= LPGL_TEST_ITEMS; i++) { + sprintf(teststr, "subtest %d", i); + begin(teststr); + grouplock_file("parallel_grouplock", i); + end(teststr); + } + } } void usage(char *proc) { - int i; - - if (rank == 0) { - printf("Usage: %s [-h] -d [-n ]\n", proc); - printf(" [-t ] [-v] [-V #] [-g]\n"); - printf("\t-h: prints this help message\n"); - printf("\t-d: the directory in which the tests will run\n"); - printf("\t-n: repeat test # times\n"); - printf("\t-t: run a particular test #\n"); - printf("\t-v: increase the verbositly level by 1\n"); - printf("\t-V: select a specific verbosity level\n"); - printf("\t-g: debug mode\n"); - } - - MPI_Initialized(&i); - if (i) MPI_Finalize(); - exit(0); + int i; + + if (rank == 0) { + printf("Usage: %s [-h] -d [-n ]\n", proc); + printf(" [-t ] [-v] [-V #] [-g]\n"); + printf("\t-h: prints this help message\n"); + printf("\t-d: the directory in which the tests will run\n"); + printf("\t-n: repeat test # times\n"); + printf("\t-t: run a particular test #\n"); + printf("\t-v: increase the verbositly level by 1\n"); + printf("\t-V: select a specific verbosity level\n"); + printf("\t-g: debug mode\n"); + } + + MPI_Initialized(&i); + if (i) + MPI_Finalize(); + exit(0); } int main(int argc, char *argv[]) { - int i, iterations = 1, c; - - setbuf(stdout, 0); - setbuf(stderr, 0); - - /* Check for -h parameter before MPI_Init so the binary can be - called directly, without, for instance, mpirun */ - for (i = 1; i < argc; ++i) { - if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) - usage(argv[0]); - } - - MPI_Init(&argc, &argv); - MPI_Comm_rank(MPI_COMM_WORLD, &rank); - MPI_Comm_size(MPI_COMM_WORLD, &size); - - /* Parse command line options */ - while (1) { - c = getopt(argc, argv, "d:ghn:t:vV:"); - if (c == -1) - break; - - switch (c) { - case 'd': - testdir = optarg; - break; - case 'g': - debug = 1; - break; - case 'h': - usage(argv[0]); - break; - case 'n': - iterations = atoi(optarg); - break; - case 't': - only_test = atoi(optarg); - break; - case 'v': - verbose += 1; - break; - case 'V': - verbose = atoi(optarg); - break; - } - } - - if (rank == 0) - printf("%s is running with %d task(es) %s\n", - argv[0], size, debug ? "in DEBUG mode" : "\b\b"); - - if (size < MIN_GLHOST) { - fprintf(stderr, "Error: " - "%d tasks run, but should be at least %d tasks to run " - "the test!\n", size, MIN_GLHOST); - MPI_Abort(MPI_COMM_WORLD, 2); - } - - if (testdir == NULL && rank == 0) { - fprintf(stderr, "Please specify a test directory! " - "(\"%s -h\" for help)\n", - argv[0]); - MPI_Abort(MPI_COMM_WORLD, 2); - } - - lp_gethostname(); - - for (i = 0; i < iterations; ++i) { - if (rank == 0) - printf("%s: Running test #%s(iter %d)\n", - timestamp(), argv[0], i); - - parallel_grouplock(); - MPI_Barrier(MPI_COMM_WORLD); - } - - if (rank == 0) { - printf("%s: All tests passed!\n", timestamp()); - } - MPI_Finalize(); - return 0; + int i, iterations = 1, c; + + setbuf(stdout, 0); + setbuf(stderr, 0); + + /* + * Check for -h parameter before MPI_Init so the binary can be + * called directly, without, for instance, mpirun + */ + for (i = 1; i < argc; ++i) { + if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) + usage(argv[0]); + } + + MPI_Init(&argc, &argv); + MPI_Comm_rank(MPI_COMM_WORLD, &rank); + MPI_Comm_size(MPI_COMM_WORLD, &size); + + /* Parse command line options */ + while (1) { + c = getopt(argc, argv, "d:ghn:t:vV:"); + if (c == -1) + break; + + switch (c) { + case 'd': + testdir = optarg; + break; + case 'g': + debug = 1; + break; + case 'h': + usage(argv[0]); + break; + case 'n': + iterations = atoi(optarg); + break; + case 't': + only_test = atoi(optarg); + break; + case 'v': + verbose += 1; + break; + case 'V': + verbose = atoi(optarg); + break; + } + } + + if (rank == 0) + printf("%s is running with %d task(es) %s\n", + argv[0], size, debug ? "in DEBUG mode" : "\b\b"); + + if (size < MIN_GLHOST) { + fprintf(stderr, + "Error: %d tasks run, but should be at least %d tasks to run the test!\n", + size, MIN_GLHOST); + MPI_Abort(MPI_COMM_WORLD, 2); + } + + if (!testdir && rank == 0) { + fprintf(stderr, + "Please specify a test directory! (\"%s -h\" for help)\n", + argv[0]); + MPI_Abort(MPI_COMM_WORLD, 2); + } + + lp_gethostname(); + + for (i = 0; i < iterations; ++i) { + if (rank == 0) + printf("%s: Running test #%s(iter %d)\n", + timestamp(), argv[0], i); + + parallel_grouplock(); + MPI_Barrier(MPI_COMM_WORLD); + } + + if (rank == 0) + printf("%s: All tests passed!\n", timestamp()); + + MPI_Finalize(); + return 0; }