b=2657

Added group lock tests. Those are not built by default.

lustre/tests/Makefile.am

@@ -72,6 +72,8 @@ sleeptest_SOURCES = sleeptest.c
 #write_append_truncate_CC=mpicc
 #createmany_mpi_SOURCES=createmany_mpi.c
 #createmany_mpi_CC=mpicc
+#parallel_grouplock_SOURCES=parallel_grouplock.c lp_utils.c
+#parallel_grouplock_CC=mpicc
 copy_attr_SOURCES= copy_attr.c
 copy_attr_LDADD= -lattr
 

lustre/tests/lp_utils.c

+/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
+ * vim:expandtab:shiftwidth=8:tabstop=8:
+ *
+ * Copyright (C) 2002 Cluster File Systems, Inc.
+ *   Author: You Feng <youfeng@clusterfs.com>
+ *
+ *   This file is part of Lustre, http://www.lustre.org.
+ *
+ *   Lustre is free software; you can redistribute it and/or
+ *   modify it under the terms of version 2 of the GNU General Public
+ *   License as published by the Free Software Foundation.
+ *
+ *   Lustre is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with Lustre; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <mpi.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <errno.h>
+#include "lustre/lustre_user.h"
+#include "lp_utils.h"
+
+#define MAX_PROCESSES 8
+
+int verbose = 0;
+int debug = 0;
+
+char hostname[1024];
+
+struct timeval t1, t2;
+
+char *timestamp() {
+        static char datestring[80];
+        time_t timestamp;
+
+        fflush(stdout);
+        timestamp = time(NULL);
+        strftime(datestring, 80, "%T", localtime(&timestamp));
+
+        return datestring;
+}
+
+inline void begin(char *str) {
+        if (verbose > 0 && rank == 0) {
+                gettimeofday(&t1, NULL);
+                printf("%s:\tBeginning %s\n", timestamp(), str);
+                fflush(stdout);
+        }
+}
+
+inline void end(char *str) {
+        float elapsed;
+
+        MPI_Barrier(MPI_COMM_WORLD);
+        if (verbose > 0 && rank == 0) {
+                gettimeofday(&t2, NULL);
+                elapsed = (t2.tv_sec + ((float)t2.tv_usec/1000000))
+                          - (t1.tv_sec + ((float)t1.tv_usec/1000000));
+                if (elapsed >= 60) {
+                        printf("%s:\tFinished %-15s(%.2f min)\n",
+                               timestamp(), str, elapsed / 60);
+                } else {
+                        printf("%s:\tFinished %-15s(%.3f sec)\n",
+		               timestamp(), str, elapsed);
+
+                }
+                fflush(stdout);
+        }
+}
+
+void dump_diff(char *orig_buf, char *buf, int size, long _off)
+{
+        int i, diff, off;
+        char *p, *end;
+
+        printf("commpared buf size %d, at offset %lu\n\n", size, _off);
+
+        if (orig_buf) {
+                printf("original buf:\n");
+                p = orig_buf;
+                end = orig_buf + size;
+                i = 1;
+                while (p < end) {
+                        printf(" %8lx", *(long *)p);
+                        p += sizeof(long);
+                        if (i++%8 == 0)
+                                printf("\n");
+                }
+                if (i%8) printf("\n\n");
+                else printf("\n");
+        }
+
+        if (buf) {
+                printf("different data: diff_data(orig_data)\n");
+                diff = 0;
+                off = 0;
+                i = 1;
+                p = buf;
+                end = buf + size;
+                while (p < end) {
+                        if (memcmp(p, orig_buf + off, sizeof(long)) != 0) {
+                                printf("\toff: %5d,\tdata: %8lx (%8lx)\n", off,
+                                       *(unsigned long *)p,
+                                       *(unsigned long *)(orig_buf + off));
+                                diff++;
+                        }
+                        off += sizeof(long);
+                        p += sizeof(long);
+                }
+                printf("\n %d total differents found\n\n", diff);
+        }
+}
+
+void lp_gethostname(void)
+{
+        if (gethostname(hostname, 1024) == -1) {
+                fprintf(stderr, "gethostname: (%d)%s", errno, strerror(errno));
+                MPI_Abort(MPI_COMM_WORLD, 2);
+        }
+}
+
+/* This function does not FAIL if the requested "name" does not exit.
+ * This is just to clean up any files or directories left over from
+ * previous runs
+ */
+void remove_file_or_dir(char *name)
+{
+        struct stat statbuf;
+        char errmsg[MAX_FILENAME_LEN + 20];
+
+        if (stat(name, &statbuf) != -1) {
+                if (S_ISREG(statbuf.st_mode)) {
+                        printf("stale file found\n");
+                        if (unlink(name) == -1) {
+                                sprintf(errmsg, "unlink of %s", name);
+                                FAIL(errmsg);
+                        }
+                }
+                if (S_ISDIR(statbuf.st_mode)) {
+                        printf("stale directory found\n");
+                        if (rmdir(name) == -1) {
+                                sprintf(errmsg, "rmdir of %s", name);
+                                FAIL(errmsg);
+                        }
+                }
+        }
+}
+
+void create_file(char *name, long filesize, int fill)
+{
+        static char filename[MAX_FILENAME_LEN];
+        char errmsg[MAX_FILENAME_LEN + 20];
+        char buf[1024 * 8];
+        char c = 'A' + size;
+        int fd, rc;
+        short zero = 0;
+        long left = filesize;
+
+        /* Process 0 creates the test file(s) */
+        if (rank == 0) {
+                sprintf(filename, "%s/%s", testdir, name);
+                remove_file_or_dir(filename);
+                if ((fd = creat(filename, FILEMODE)) == -1) {
+                        sprintf(errmsg, "create of file %s", filename);
+                        FAIL(errmsg);
+                }
+                if (filesize > 0) {
+                        if (lseek(fd, filesize - 1, SEEK_SET) == -1) {
+                                close(fd);
+                                sprintf(errmsg, "lseek of file %s", filename);
+                                FAIL(errmsg);
+                        }
+                        if (write(fd, &zero, 1) == -1) {
+                                close(fd);
+                                sprintf(errmsg, "write of file %s", filename);
+                                FAIL(errmsg);
+                        }
+                }
+                if (filesize > 0 && fill) {
+                        if (lseek(fd, 0, SEEK_SET) == -1) {
+                                close(fd);
+                                sprintf(errmsg, "lseek of file %s", filename);
+                                FAIL(errmsg);
+                        }
+                        memset(buf, c, 1024);
+                        while (left > 0) {
+                                if ((rc = write(fd, buf,
+                                                left > (1024 * 8) ? (1024 * 8) : left))
+                                    == -1) {
+                                        close(fd);
+                                        sprintf(errmsg, "write of file %s", filename);
+                                        FAIL(errmsg);
+                                }
+                                left -= rc;
+                        }
+                }
+                if (close(fd) == -1) {
+                        sprintf(errmsg, "close of file %s", filename);
+                        FAIL(errmsg);
+                }
+        }
+}
+
+void check_stat(char *filename, struct stat *state, struct stat *old_state)
+{
+        char errmsg[MAX_FILENAME_LEN+20];
+
+        if (stat(filename, state) == -1) {
+                sprintf(errmsg, "stat of file %s", filename);
+                FAIL(errmsg);
+        }
+
+        if (memcmp(state, old_state, sizeof(struct stat)) != 0) {
+                errno = 0;
+                sprintf(errmsg, LP_STAT_FMT, LP_STAT_ARGS);
+                FAIL(errmsg);
+        }
+}
+
+void remove_file(char *name)
+{
+        char filename[MAX_FILENAME_LEN];
+        char errmsg[MAX_FILENAME_LEN + 20];
+
+        /* Process 0 remove the file(s) */
+        if (rank == 0) {
+                sprintf(filename, "%s/%s", testdir, name);
+                if (unlink(filename) == -1) {
+                        sprintf(errmsg, "unlink of file %s", filename);
+                        FAIL(errmsg);
+                }
+        }
+}
+
+void fill_stride(char *buf, int buf_size, long long rank, long long _off)
+{
+        char *p = buf;
+        long long off, data[2];
+        int cp, left = buf_size;
+
+        data[0] = rank;
+        off = _off;
+        while (left > 0) {
+                data[1] = off;
+                cp = left > sizeof(data) ? sizeof(data) : left;
+                memcpy(p, data, cp);
+                off += cp;
+                p += cp;
+                left -= cp;
+        }
+}

lustre/tests/lp_utils.h

+/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
+ * vim:expandtab:shiftwidth=8:tabstop=8:
+ *
+ * Copyright (C) 2002 Cluster File Systems, Inc.
+ *   Author: You Feng <youfeng@clusterfs.com>
+ *
+ *   This file is part of Lustre, http://www.lustre.org.
+ *
+ *   Lustre is free software; you can redistribute it and/or
+ *   modify it under the terms of version 2 of the GNU General Public
+ *   License as published by the Free Software Foundation.
+ *
+ *   Lustre is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with Lustre; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __LP_UTILS_H__
+#define __LP_UTILS_H__
+
+#include "lustre/lustre_user.h"
+
+#define FAIL(msg) \
+ \
+do { \
+        printf("%s: Process %d (%s)\n", timestamp(), rank, hostname); \
+        if (debug) \
+                printf("\tFAILED in %s:%d:%s()\n", __FILE__, __LINE__, __func__); \
+        else \
+                printf("\tFAILED in %s()\n", __func__); \
+        printf("%s", msg); \
+        fflush(stdout); \
+        MPI_Abort(MPI_COMM_WORLD, 1); \
+} while(0)
+
+#define FILEMODE S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH
+#define MAX_FILENAME_LEN 512
+
+extern int verbose;
+extern int debug;
+
+extern int rank;
+extern int size;
+
+extern char hostname[];
+extern char *timestamp();
+extern char *testdir;
+
+extern inline void begin(char *str);
+extern inline void end(char *str);
+
+extern void dump_diff(char *orig_buf, char *buf, int len, long off);
+extern void lp_gethostname(void);
+
+extern void create_file(char *name, long filesize, int fill);
+extern void fill_file(char *name, long filesize);
+
+#define LP_STAT_FMT \
+ \
+"Stat error:\n \
+\tfields\t\tvalue\told value\n \
+\tst_dev\t\t%d\t%d\n \
+\tst_ino\t\t%d\t%d\n \
+\tst_mode\t\t%o\t%o\n \
+\tst_nlink\t%d\t%d\n \
+\tst_uid\t\t%d\t%d\n \
+\tst_gid\t\t%d\t%d\n \
+\tst_rdev\t\t%x.%x\t%x.%x\n \
+\tst_size\t\t%lu\t%lu\n \
+\tst_blksize\t%d\t%d\n \
+\tst_blocks\t%u\t%u\n \
+\tst_atime\t%d\t%d\n \
+\tst_mtime\t%d\t%d\n \
+\tst_ctime\t%d\t%d\n"
+                                                                                
+#define LP_STAT_ARGS \
+ \
+(int)state->st_dev, (int)old_state->st_dev, \
+(int)state->st_ino, (int)old_state->st_ino, \
+state->st_mode & 07777, old_state->st_mode & 07777, \
+(int)state->st_nlink, (int)old_state->st_nlink, \
+state->st_uid, old_state->st_uid, \
+state->st_gid, old_state->st_gid, \
+(int)((state->st_rdev >> 8) & 0xff), (int)(state->st_rdev & 0xff), \
+(int)((old_state->st_rdev >> 8) & 0xff), (int)(old_state->st_rdev & 0xff), \
+(unsigned long)state->st_size, (unsigned long)old_state->st_size, \
+(int)state->st_blksize, (int)old_state->st_blksize, \
+(unsigned int)state->st_blocks, (unsigned int)old_state->st_blocks, \
+(int)state->st_atime, (int)old_state->st_atime, \
+(int)state->st_mtime, (int)old_state->st_mtime, \
+(int)state->st_ctime, (int)old_state->st_ctime
+
+extern void check_stat(char *filename, struct stat *state, struct stat *old_state);
+extern void remove_file(char *name);
+extern void remove_file_or_dir(char *name);
+extern void fill_stride(char *buf, int buf_size, long long rank, long long _off);
+
+#endif /* __LP_UTILS_H__ */