runtests.sh: Make test bit more generic

index 305cbeb..19f7e3b 100644
@@ -9,8 +9,6 @@
 #define TEST_FILE	"data.d/data.filelock1"
 #define LOG_FILE	"logs.d/log.filelock1"
 
-typedef unsigned long long u64;
-
 extern FILE *logfp;
 int test_fd;
 int event_fd1;

@@ -31,57 +29,6 @@ int event_fd2;
  * 	held by the other process.
  */
 
-setup_notification()
-{
-	int efd;
-
-	efd = eventfd(0, 0);
-	if (efd < 0) {
-		fprintf(logfp, "ERROR: eventfd(): %s\n", strerror(errno));
-		do_exit(1);
-	}
-	return efd;
-}
-
-wait_for_events(int efd, u64 total)
-{
-	int n;
-	u64 events;
-	u64 count = (u64)0;
-
-	do {
-		fprintf(logfp, "%d: wait_for_events: fd %d, reading for %llu\n",
-				getpid(), efd, total);
-		fflush(logfp);
-
-		n = read(efd, &events, sizeof(events));
-		if (n != sizeof(events)) {
-			fprintf(logfp, "ERROR: read(event_fd) %s\n",
-						strerror(errno));
-			do_exit(1);
-		}
-		fprintf(logfp, "%d: wait_for_events: fd %d read %llu\n",
-				getpid(), efd, events);
-
-		count += events;
-	} while (count < total);
-}
-
-notify_one_event(int efd)
-{
-	int n;
-	u64 event = (u64)1;
-
-	fprintf(logfp, "%d: Notifying one event on fd %d\n", getpid(), efd);
-	fflush(logfp);
-
-	n = write(efd, &event, sizeof(event));
-	if (n != sizeof(event)) {
-		fprintf(logfp, "ERROR: write(event_fd) %s\n", strerror(errno));
-		do_exit(1);
-	}
-}
-
 struct test_arg {
 	int child_idx;
 	int type;

63 lines not on this page · raw message

index a42c178..9a0a13e 100644
@@ -12,6 +12,10 @@ struct record {
 	char data[256];
 };
 
+#ifdef __i386__
+typedef unsigned long long u64;
+#endif
+
 extern void do_exit(int status);
 extern int test_done(void);
 extern int test_checkpoint_done();

@@ -23,4 +27,7 @@ extern char *freezer_mountpoint(void);
 /* right now, subsys must always be "freezer" */
 extern int move_to_cgroup(char *subsys, char *grp, int pid);
 
+extern void notify_one_event(int efd);
+extern void wait_for_events(int efd, u64 total);
+extern int setup_notification();
 #endif /* LIBCRTEST_H */

262 lines not on this page · raw message

268 lines not on this page · raw message

index b29042a..c20da5e 100644
@@ -58,7 +58,7 @@ void set_checkpoint_ready()
 	close(fd);
 }
 
-static void print_exit_status(int pid, int status)
+void print_exit_status(int pid, int status)
 {
 	fprintf(logfp, "Pid %d unexpected exit - ", pid);
 	if (WIFEXITED(status)) {

index 19f7e3b..34e9ad2 100644
@@ -4,6 +4,7 @@
 #include <string.h>
 #include <signal.h>
 #include <errno.h>
+#include <sys/stat.h>
 #include "libcrtest.h"
 
 #define TEST_FILE	"data.d/data.filelock1"

@@ -13,6 +14,7 @@ extern FILE *logfp;
 int test_fd;
 int event_fd1;
 int event_fd2;
+int mandatory_locks = 1;
 
 /*
  * Description:

@@ -60,6 +62,9 @@ void set_lock(int fd, struct test_arg *tlock)
 		fprintf(logfp, "%d: set_lock(): ERROR [%d, %llu, %llu]: %s\n",
 				getpid(), tlock->type, (u64)tlock->start,
 				(u64)tlock->len, strerror(errno));
+		if (mandatory_locks)
+			fprintf(logfp, "\n\t***** Is the FS mounted with "
+					"'-o mand' option ?\n\n");
 		fflush(logfp);
 		kill(getppid(), SIGUSR1);
 		do_exit(1);

@@ -108,6 +113,9 @@ void test_lock(int fd, int locked_by_me, struct test_arg *tlock)
 	} else if (rc < 0) {
 		fprintf(logfp, "ERROR: fcntl(F_SETLK): %s, error %s\n",
 				lock_info, strerror(errno));
+		if (mandatory_locks)
+			fprintf(logfp, "\n\t***** Is the FS mounted with "
+					"'-o mand' option ?\n\n");
 		goto error;
 	}
 

@@ -215,8 +223,12 @@ int do_child1(int idx)
 void setup_test_file()
 {
 	char buf[256];
+	int mode;
+	int rc;
+
+	mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH; /* 0666 */
 
-	test_fd = open(TEST_FILE, O_RDWR|O_CREAT|O_TRUNC, 0666);
+	test_fd = open(TEST_FILE, O_RDWR|O_CREAT|O_TRUNC, mode);
 	if (test_fd < 0) {
 		fprintf(logfp, "ERROR: open(%s): %s\n", TEST_FILE,
 				strerror(errno));

@@ -225,6 +237,23 @@ void setup_test_file()
 
 	memset(buf, 0, sizeof(buf));
 	write(test_fd, buf, sizeof(buf));
+
+	if (!mandatory_locks)
+		return;
+
+	/* Enable mandatory file locks (setgid, clear group execute) */
+	mode |= S_ISGID;
+	mode &= ~S_IXGRP;
+
+	rc = fchmod(test_fd, mode);
+	if (rc < 0) {
+		fprintf(logfp, "ERROR: fchmod(%s): rc %d, error %s\n",
+				TEST_FILE, rc, strerror(errno));
+		fprintf(logfp, "Maybe '-o mand' mount option is not set ?\n");
+		do_exit(1);
+	}
+	fprintf(logfp, "Mandatory locking set on %s, mode 0%o\n", TEST_FILE,
+			mode);
 }
 
 int pid1, pid2;

@@ -238,25 +267,32 @@ void child_handler(int sig)
 
 	if (sig == SIGCHLD)
 		do_wait(1);
+
 	fprintf(logfp, "%d: Test case FAILED\n", getpid());
 	fflush(logfp);
 	/*
 	 * Kill (remaining) children and exit.
 	 */
-	kill(pid1, SIGKILL);
-	kill(pid2, SIGKILL);
+	if (pid1)
+		kill(pid1, SIGKILL);
+	if (pid2)
+		kill(pid2, SIGKILL);
 
 	do_exit(-1);
 }
 
-main(int argc, char *argv[])
+usage(char *argv[])
 {
-	int i, status, rc;
+	fprintf(logfp, "Usage: %s [-m]\n", argv[0]);
+	fprintf(logfp, "\tTest POSIX (advisory) file locks (without -m)\n");
+	fprintf(logfp, "\t-m: Test mandatory file locks\n");
+	fprintf(logfp, "Test FAILED\n");
+	do_exit(1);
+}
 
-	if (test_done()) {
-		printf("Remove %s before running test\n", TEST_DONE);
-		do_exit(1);
-	}
+main(int argc, char *argv[])
+{
+	int i, c, status, rc;
 
 	logfp = fopen(LOG_FILE, "w");
 	if (!logfp) {

@@ -264,6 +300,19 @@ main(int argc, char *argv[])
 		do_exit(1);
 	}
 
+	mandatory_locks = 0;
+	while((c = getopt(argc, argv, "m")) != EOF) {
+		switch (c) {
+			case 'm': mandatory_locks = 1; break;
+			default: usage(argv);
+		}
+	}
+
+	if (test_done()) {
+		printf("Remove %s before running test\n", TEST_DONE);
+		do_exit(1);
+	}
+
 	printf("%s: Closing stdio fds and writing messages to %s\n",
 			argv[0], LOG_FILE);
 

index fa45127..d1743de 100644
@@ -9,6 +9,10 @@
 
 int num_threads = 5;
 FILE *logfp;
+/*
+ * Use LOG_PREFIX with thread index as suffix, if each thread needs a
+ * separate log file. For now, we use a single log
+ */
 #define LOG_PREFIX		"logs.d/pthread1"
 
 static void usage(char *argv[])

@@ -137,7 +141,6 @@ main(int argc, char *argv[])
 	pthread_t *tid_list;
 	char log_file[256];
 
-	for (i=0; i<100; i++) close(i);
 	sprintf(log_file, "%s.log", LOG_PREFIX);
 
 	logfp = fopen(log_file, "w");

@@ -148,6 +151,13 @@ main(int argc, char *argv[])
 		do_exit(1);
 	}
 
+	fprintf(stderr, "Redirecting output to logfile %s\n", log_file);
+
+	for (i=0; i<100; i++) {
+		if (i != fileno(logfp))
+			close(i);
+	}
+
 	if (test_done()) {
 		printf("Remove %s before running test\n", TEST_DONE);
 		do_exit(1);

new file mode 100644
index 0000000..e24ce54
@@ -0,0 +1,421 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include <signal.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include "libcrtest.h"
+
+#define TEST_FILE	"data.d/data.filelock2"
+#define LOG_FILE	"logs.d/log.filelock2"
+
+extern FILE *logfp;
+int test_fd;
+int event_fd1;
+int event_fd2;
+int mandatory_locks = 1;
+
+/*
+ * Description:
+ * 	Ensure that a process waiting for a range lock on a file the time
+ * 	of checkpoint is properly notified after restart from the checkpoint.
+ *
+ * Implementation:
+ * 	Process P1 acquires a F_WRLCK on a range and waits for checkpoint.
+ * 	Process P2 waits in F_SETLKW. After the checkpoint, P1 confirms
+ * 	that it still has the lock and then unlocks the range. P2 must
+ * 	return succesfully from the fcntl() and must acquire the lock.
+ */
+struct test_record {
+	int start;
+	int len;
+};
+
+struct test_record test_record = { 0, 17 };
+
+void set_lock(int fd, int lock_type, struct test_record *rec)
+{
+	int rc;
+	struct flock lock;
+
+	lock.l_type = lock_type;
+	lock.l_whence = SEEK_SET;
+	lock.l_start = (off_t)rec->start;
+	lock.l_len = (off_t)rec->len;
+
+	rc = fcntl(fd, F_SETLKW, &lock);
+	if (rc < 0 && errno != EAGAIN) {
+		fprintf(logfp, "%d: set_lock(): ERROR [%d, %llu, %llu]: %s\n",
+				getpid(), lock_type, (u64)rec->start,
+				(u64)rec->len, strerror(errno));
+		if (mandatory_locks)
+			fprintf(logfp, "\n\t***** Is the FS mounted with "
+					"'-o mand' option ?\n\n");
+		fflush(logfp);
+		kill(getppid(), SIGUSR1);
+		do_exit(1);
+	}
+
+	fprintf(logfp, "%d: set_lock(): [%d, %llu, %llu] %s\n", getpid(),
+			lock_type, (u64)rec->start, (u64)rec->len,
+			rc < 0 ? strerror(errno) : "done");
+}
+/*
+ * If @set is TRUE, ensure that the given lock is set.
+ * If @set is FALSE, ensure that the given lock is NOT set.
+ */
+void test_lock(int fd, int lock_type, struct test_record *rec)
+{
+	int rc;
+	int conflict;
+	struct flock lock;
+	char lock_info[512];
+
+	lock.l_type = lock_type;
+	lock.l_whence = SEEK_SET;
+	lock.l_start = (off_t)rec->start;
+	lock.l_len = (off_t)rec->len;
+	lock.l_pid = 0;
+
+	sprintf(lock_info, "lock [%d, %llu, %llu] ", lock_type,
+			(u64)rec->start, (u64)rec->len);
+
+	conflict = 0;
+	rc = fcntl(fd, F_SETLK, &lock);
+	if (rc < 0 && (errno == EAGAIN || errno == EACCES)) {
+		rc = fcntl(fd, F_GETLK, &lock);
+		if (rc < 0) {
+			fprintf(logfp, "ERROR: fcntl(F_GETLK): %s, error %s\n",
+					lock_info, strerror(errno));
+			goto error;
+		}
+
+		if (lock.l_type == F_UNLCK || lock.l_pid == 0) {
+			fprintf(logfp, "%d: ERROR: %s F_SETLK / F_GETLK "
+					"mismatch !!!\n", getpid(), lock_info);
+			goto error;
+		}
+		conflict = 1;
+	} else if (rc < 0) {
+		fprintf(logfp, "ERROR: fcntl(F_SETLK): %s, error %s\n",
+				lock_info, strerror(errno));
+		if (mandatory_locks)
+			fprintf(logfp, "\n\t***** Is the FS mounted with "
+					"'-o mand' option ?\n\n");
+		goto error;
+	}
+
+	fprintf(logfp, "%d: %s, conflict %d\n", getpid(), lock_info, conflict);
+
+	if (conflict) {
+		fprintf(logfp, "%d: FAIL: %s is NOT set by me !!!\n", getpid(),
+				lock_info);
+		goto error;
+	} else {
+		fprintf(logfp, "%d: PASS: %s is set by me\n", getpid(),
+				lock_info);
+		return;
+	}
+
+error:
+	fflush(logfp);
+	kill(getppid(), SIGUSR1);
+	do_exit(1);
+}
+
+void handler(int sig)
+{
+	/*
+	 * We completed the test and sibling completed its test. Safe to
+	 * exit.
+	 */
+	fprintf(logfp, "%d: Ok to exit...\n", getpid());
+	fflush(logfp);
+	do_exit(0);
+}
+
+/*
+ * Notify parent that we are done testing and wait for a SIGINT to
+ * exit cleanly. Parent will wait for sibling to also exit and then
+ * signal us. This orderly exit will help parent distinguish this
+ * exit from an unexpected exit by the children.
+ */
+exit_cleanly()
+{
+        notify_one_event(event_fd2);
+        pause();
+	do_exit(0);
+}
+
+int do_child1(int idx)
+{
+	int rc;
+	int i;
+	int num_locks;
+	int failed;
+	
+	fprintf(logfp, "%d: Child %d starting up\n", getpid(), idx);
+	fflush(logfp);
+
+	signal(SIGINT, handler);
+
+	set_lock(test_fd, F_WRLCK, &test_record);
+
+	/*
+	 * Tell parent we are ready for checkpoint...
+	 */
+	notify_one_event(event_fd1);
+
+	/*
+	 * Wait for checkpoint/restart
+	 */
+	fprintf(logfp, "%d: waiting for test-done\n", getpid());
+	fflush(logfp);
+	while(!test_done()) {
+		sleep(1);
+	}
+	fprintf(logfp, "%d: Found test-done\n", getpid());
+	fflush(logfp);
+
+	test_lock(test_fd, F_WRLCK, &test_record);
+
+	/*
+ 	 * Drop our lock and exit. Sibling can then acquire the lock.
+	 */
+	set_lock(test_fd, F_UNLCK, &test_record);
+
+	exit_cleanly();
+}
+
+int do_child2(int idx)
+{
+	int rc;
+	int i;
+	int num_locks;
+	int failed;
+	
+	fprintf(logfp, "%d: Child %d starting up\n", getpid(), idx);
+	fflush(logfp);
+
+	signal(SIGINT, handler);
+
+	/*
+	 * Tell parent we are about to get the lock.
+	 * NOTE: There is still a window between now and when we actually
+	 * 	 block in the F_SETLK. But the parent has to guess and sleep()
+	 * 	 before enabling checkpoint.
+	 */
+	notify_one_event(event_fd1);
+
+	/* This should block, until checkpoint/restart is done */
+	set_lock(test_fd, F_WRLCK, &test_record);
+
+	/*
+	 * We must got here after checkpoint/restart. If not, something is
+	 * wrong ?
+	 */
+	if (!test_checkpoint_done()) {
+		fprintf(logfp, "Child2: ERROR: expected C/R to be done "
+				"by now, but is not ?\n");
+		do_exit(1);
+	}
+
+	/*
+	 * Since we get here after checkpoint/restart, ensure we have the lock.
+	 */
+	test_lock(test_fd, F_WRLCK, &test_record);
+
+	exit_cleanly();
+}
+
+/*
+ * Populate the test file so the children can lock some portions of
+ * the file
+ */
+void setup_test_file()
+{
+	char buf[256];
+	int mode;
+	int rc;
+
+	mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH; /* 0666 */
+
+	test_fd = open(TEST_FILE, O_RDWR|O_CREAT|O_TRUNC, mode);
+	if (test_fd < 0) {
+		fprintf(logfp, "ERROR: open(%s): %s\n", TEST_FILE,
+				strerror(errno));
+		do_exit(1);
+	}
+
+	memset(buf, 0, sizeof(buf));
+	write(test_fd, buf, sizeof(buf));
+
+	if (!mandatory_locks)
+		return;
+
+	/* Enable mandatory file locks (setgid, clear group execute) */
+	mode |= S_ISGID;
+	mode &= ~S_IXGRP;
+
+	rc = fchmod(test_fd, mode);
+	if (rc < 0) {
+		fprintf(logfp, "ERROR: fchmod(%s): rc %d, error %s\n",
+				TEST_FILE, rc, strerror(errno));
+		fprintf(logfp, "Maybe '-o mand' mount option is not set ?\n");
+		do_exit(1);
+	}
+	fprintf(logfp, "Mandatory locking set on %s, mode 0%o\n", TEST_FILE,
+			mode);
+}
+
+int pid1, pid2;
+
+kill_children(int sig)
+{
+	signal(SIGCHLD, SIG_DFL);
+	if (pid1)
+		kill(pid1, sig);
+
+	if (pid2)
+		kill(pid2, sig);
+	do_wait(2);
+}
+
+/*
+ * We get a SIGCHLD if a child exited prematurely. SIGUSR1 if child
+ * exited due to an error.
+ */
+void child_handler(int sig)
+{
+	fprintf(logfp, "%d: Got signal %d. Test case FAILED\n", getpid(), sig);
+	fflush(logfp);
+
+	/*
+	 * Kill (remaining) children and exit.
+	 */
+	kill_children(SIGKILL);
+
+	do_exit(-1);
+}
+
+usage(char *argv[])
+{
+	fprintf(logfp, "Usage: %s [-m]\n", argv[0]);
+	fprintf(logfp, "\tTest POSIX (advisory) file locks (without -m)\n");
+	fprintf(logfp, "\t-m: Test mandatory file locks\n");
+	fprintf(logfp, "Test FAILED\n");
+	do_exit(1);
+}
+
+int create_child(int idx, int (*child_func)(int))
+{
+	int rc;
+
+	rc = fork();
+	if (rc == 0)
+		(*child_func)(idx);
+
+	if (rc < 0) {
+		fprintf(logfp, "%d: fork() failed, error %s\n", getpid(), 
+				strerror(errno));
+		kill_children(SIGKILL);
+	}
+
+	wait_for_events(event_fd1, 1);
+
+	return rc;
+}
+
+main(int argc, char *argv[])
+{
+	int i, c, status, rc;
+
+	logfp = fopen(LOG_FILE, "w");
+	if (!logfp) {
+		perror("open() logfile");
+		do_exit(1);
+	}
+
+	fprintf(logfp, "%d: Parent starting up\n", getpid());
+	fflush(logfp);
+
+	mandatory_locks = 0;
+	while((c = getopt(argc, argv, "m")) != EOF) {
+		switch (c) {
+			case 'm': mandatory_locks = 1; break;
+			default: usage(argv);
+		}
+	}
+
+	if (test_done()) {
+		printf("Remove %s before running test\n", TEST_DONE);
+		do_exit(1);
+	}
+
+	printf("%s: Closing stdio fds and writing messages to %s\n",
+			argv[0], LOG_FILE);
+
+	for (i=0; i<100; i++)  {
+		if (fileno(logfp) != i)
+			close(i);
+	}
+
+	setup_test_file();
+	event_fd1 = setup_notification();
+	event_fd2 = setup_notification();
+
+	/*
+	 * Before waiting for events below, ensure we will be notified
+	 * if a child encounters an error and/or exits prematurely.
+	 */
+	signal(SIGCHLD, child_handler);
+	signal(SIGUSR1, child_handler);
+
+	/*
+	 * Create the first child and wait for it take its record lock.
+	 */
+	pid1 = create_child(0, do_child1);
+
+	/*
+	 * Create the second child and wait for it to block on the
+	 * record lock.
+	 *
+	 */
+	pid2 = create_child(1, do_child2);
+
+	/*
+	 * NOTE: We have some guessing to do here. The notification from
+	 * 	 the second child (in create_child()) just tells us that
+	 * 	 the child is _about_ to attempt the lock. Give it extra
+	 * 	 time to actually block before enabling checkpoint.
+	 */
+	sleep(10);
+
+	/*
+	 * Now that the test processes are ready, tell any wrapper scripts,
+	 * we are ready for checkpoint.
+	 */
+	set_checkpoint_ready();
+
+	fprintf(logfp, "***** %d: Ready for checkpoint\n", getpid());
+	fflush(logfp);
+
+	/*
+	 * Wait for tests to finish their testing.
+	 */
+	wait_for_events(event_fd2, 2);
+
+	/*
+	 * Now tell them that it is safe to exit.
+	 *
+	 * NOTE: This orderly exit is needed to:
+	 *
+	 * 	- ensure we don't get stuck waiting for events, and,
+	 * 	- enable us to distinguish normal and unexpected exits so
+	 * 	  we can properly report test status to wrapper scripts.
+	 */
+	kill_children(SIGINT);
+
+	do_exit(0);
+}

400 lines not on this page · raw message