[PATCH] Revert default wal_sync_method to fdatasync on Linux 2.6.33+

diff --git a/src/tools/fsync/test_fsync.c b/src/tools/fsync/test_fsync.c
index 28c2119..12a83e1 100644
*** a/src/tools/fsync/test_fsync.c
--- b/src/tools/fsync/test_fsync.c
***************
*** 23,34 ****
  #include <string.h>
  
  
! #ifdef WIN32
  #define FSYNC_FILENAME	"./test_fsync.out"
- #else
- /* /tmp might be a memory file system */
- #define FSYNC_FILENAME	"/var/tmp/test_fsync.out"
- #endif
  
  #define WRITE_SIZE	(8 * 1024)	/* 8k */
  
--- 23,32 ----
  #include <string.h>
  
  
! /* put the temp files in the local directory
!    this is a change from older versions which used
!    /var/tmp */
  #define FSYNC_FILENAME	"./test_fsync.out"
  
  #define WRITE_SIZE	(8 * 1024)	/* 8k */
  

diff --git a/src/tools/fsync/Makefile b/src/tools/fsync/Makefile
index 252c087..2ddbbe9 100644
*** a/src/tools/fsync/Makefile
--- b/src/tools/fsync/Makefile
***************
*** 4,10 ****
  #
  # Copyright (c) 2003-2010, PostgreSQL Global Development Group
  #
! # src/tools/fsync/Makefile
  #
  #-------------------------------------------------------------------------
  
--- 4,10 ----
  #
  # Copyright (c) 2003-2010, PostgreSQL Global Development Group
  #
! # $PostgreSQL: pgsql/src/tools/fsync/Makefile,v 1.9 2010/07/05 18:54:38 tgl Exp $
  #
  #-------------------------------------------------------------------------
  
*************** override CPPFLAGS := -I$(libpq_srcdir) $
*** 16,24 ****
  
  OBJS= test_fsync.o
  
! all: test_fsync
  
! test_fsync: test_fsync.o | submake-libpq submake-libpgport
  	$(CC) $(CFLAGS) test_fsync.o $(libpq_pgport) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X)
  
  clean distclean maintainer-clean:
--- 16,24 ----
  
  OBJS= test_fsync.o
  
! all: submake-libpq submake-libpgport test_fsync
  
! test_fsync: test_fsync.o $(libpq_builddir)/libpq.a
  	$(CC) $(CFLAGS) test_fsync.o $(libpq_pgport) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X)
  
  clean distclean maintainer-clean:
diff --git a/src/tools/fsync/README b/src/tools/fsync/README
index 6d9acd3..5b45581 100644
*** a/src/tools/fsync/README
--- b/src/tools/fsync/README
***************
*** 1,4 ****
! src/tools/fsync/README
  
  fsync
  =====
--- 1,4 ----
! $PostgreSQL: pgsql/src/tools/fsync/README,v 1.5 2009/11/28 15:04:54 momjian Exp $
  
  fsync
  =====
*************** fsync
*** 6,11 ****
  This program tests fsync.  The tests are described as part of the program output.
  
  	Usage:	test_fsync [-f filename] [loops]
  
! Loops defaults to 5000.  The default output file is /var/tmp/test_fsync.out.
! Consider that /tmp or /var/tmp might be memory-based file systems.
--- 6,25 ----
  This program tests fsync.  The tests are described as part of the program output.
  
  	Usage:	test_fsync [-f filename] [loops]
+ 	
+ test_fsync is intended to give you a reasonable idea of what the fastest 
+ fsync_method is on your specific system, as well as supplying diagnostic 
+ information in the event of an identified I/O problem.  However, differences
+ shown by test_fsync may not make any difference in real database throughput,
+ especially since many database servers are not speed-limited by their
+ transaction logs.
  
! Filename defaults to test_fsync.out in the current directory. test_fsync
! should be run on the same filesystem where your transaction log currently
! resides.
! 
! Loops default to 10000, except for writethrough tests, where there are 1/10 of
! that in order to make the user not wait forever.  You should lower loops if you
! have a slow system and the tests are taking more than 5 minutes each.  You should
! raise loops if your system is faster than 5000/second, in order to get useful
! statistics.
diff --git a/src/tools/fsync/test_fsync.c b/src/tools/fsync/test_fsync.c
index 28c2119..5980b70 100644
*** a/src/tools/fsync/test_fsync.c
--- b/src/tools/fsync/test_fsync.c
***************
*** 3,9 ****
   *
   *
   *	test_fsync.c
!  *		test various fsync() methods
   */
  
  #include "postgres.h"
--- 3,9 ----
   *
   *
   *	test_fsync.c
!  *		tests all supported fsync() methods
   */
  
  #include "postgres.h"
***************
*** 22,55 ****
  #include <unistd.h>
  #include <string.h>
  
! 
! #ifdef WIN32
  #define FSYNC_FILENAME	"./test_fsync.out"
- #else
- /* /tmp might be a memory file system */
- #define FSYNC_FILENAME	"/var/tmp/test_fsync.out"
- #endif
  
  #define WRITE_SIZE	(8 * 1024)	/* 8k */
  
  #define LABEL_FORMAT	"\t%-30s"
  
  int			loops = 10000;
  
  void		die(char *str);
  void		print_elapse(struct timeval start_t, struct timeval stop_t);
  
  int
  main(int argc, char *argv[])
  {
  	struct timeval start_t;
  	struct timeval stop_t;
! 	int			tmpfile,
! 				i;
  	char	   *full_buf = (char *) malloc(XLOG_SEG_SIZE),
  			   *buf;
  	char	   *filename = FSYNC_FILENAME;
  
  	if (argc > 2 && strcmp(argv[1], "-f") == 0)
  	{
  		filename = argv[2];
--- 22,58 ----
  #include <unistd.h>
  #include <string.h>
  
! /* 
!  * put the temp files in the local directory
!  * unless the user specifies otherwise 
!  */
  #define FSYNC_FILENAME	"./test_fsync.out"
  
  #define WRITE_SIZE	(8 * 1024)	/* 8k */
  
  #define LABEL_FORMAT	"\t%-30s"
  
  int			loops = 10000;
+ int			writethrough_loops = 1000;
  
  void		die(char *str);
  void		print_elapse(struct timeval start_t, struct timeval stop_t);
+ void		print_elapse_writethrough(struct timeval start_t, struct timeval stop_t);
  
  int
  main(int argc, char *argv[])
  {
  	struct timeval start_t;
  	struct timeval stop_t;
! 	int			tmpfile;
! 	int         i;
  	char	   *full_buf = (char *) malloc(XLOG_SEG_SIZE),
  			   *buf;
  	char	   *filename = FSYNC_FILENAME;
  
+ 	/* 
+ 	 * arguments: loops and filename (optional) 
+ 	 */
  	if (argc > 2 && strcmp(argv[1], "-f") == 0)
  	{
  		filename = argv[2];
*************** main(int argc, char *argv[])
*** 57,73 ****
  		argc -= 2;
  	}
  
! 	if (argc > 1)
  		loops = atoi(argv[1]);
  
  	for (i = 0; i < XLOG_SEG_SIZE; i++)
  		full_buf[i] = random();
  
  	if ((tmpfile = open(filename, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR)) == -1)
  		die("Cannot open output file.");
  	if (write(tmpfile, full_buf, XLOG_SEG_SIZE) != XLOG_SEG_SIZE)
  		die("write failed");
! 	/* fsync now so later fsync's don't have to do it */
  	if (fsync(tmpfile) != 0)
  		die("fsync failed");
  	close(tmpfile);
--- 60,88 ----
  		argc -= 2;
  	}
  
! 	/* 
! 	 * set writethrough_loops to be 1/10 of loops
! 	 * since writethroughs are very slow 
! 	 */
! 	if (argc > 1) 
! 	{
  		loops = atoi(argv[1]);
+ 		writethrough_loops = loops / 10;
+ 	}
  
  	for (i = 0; i < XLOG_SEG_SIZE; i++)
  		full_buf[i] = random();
  
+ 	/* 
+ 	 * test if we can open the target file 
+ 	 */
  	if ((tmpfile = open(filename, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR)) == -1)
  		die("Cannot open output file.");
  	if (write(tmpfile, full_buf, XLOG_SEG_SIZE) != XLOG_SEG_SIZE)
  		die("write failed");
! 	/*
! 	 * fsync now so that dirty buffers don't skew later tests
! 	 */
  	if (fsync(tmpfile) != 0)
  		die("fsync failed");
  	close(tmpfile);
*************** main(int argc, char *argv[])
*** 77,83 ****
  	printf("Loops = %d\n\n", loops);
  
  	/*
! 	 * Simple write
  	 */
  	printf("Simple write:\n");
  	printf(LABEL_FORMAT, "8k write");
--- 92,98 ----
  	printf("Loops = %d\n\n", loops);
  
  	/*
! 	 * Test a simple write without fsync
  	 */
  	printf("Simple write:\n");
  	printf(LABEL_FORMAT, "8k write");
*************** main(int argc, char *argv[])
*** 95,104 ****
  	print_elapse(start_t, stop_t);
  
  	/*
! 	 * Compare file sync methods with one 8k write
  	 */
  	printf("\nCompare file sync methods using one write:\n");
  
  #ifdef OPEN_DATASYNC_FLAG
  	printf(LABEL_FORMAT, "open_datasync 8k write");
  	fflush(stdout);
--- 110,122 ----
  	print_elapse(start_t, stop_t);
  
  	/*
! 	 * Test all fsync methods using single 8k writes
  	 */
  	printf("\nCompare file sync methods using one write:\n");
  
+ 	/*
+ 	 * Test open_datasync if available
+ 	 */
  #ifdef OPEN_DATASYNC_FLAG
  	printf(LABEL_FORMAT, "open_datasync 8k write");
  	fflush(stdout);
*************** main(int argc, char *argv[])
*** 115,124 ****
--- 133,174 ----
  	gettimeofday(&stop_t, NULL);
  	close(tmpfile);
  	print_elapse(start_t, stop_t);
+ 
+ 	/*
+ 	 * If O_DIRECT is enabled, test that with open_datasync
+ 	 */
+ 	if ( PG_O_DIRECT != 0 )
+ 	{
+ 		printf(LABEL_FORMAT, "open_datasync 8k directIO write");
+ 		fflush(stdout);
+ 		if ((tmpfile = open(filename, O_RDWR | O_DSYNC | PG_O_DIRECT, 0)) == -1)
+ 			printf("\t(unavailable: o_direct on this filesystem)\n");
+ 		else
+ 		{
+ 			gettimeofday(&start_t, NULL);
+ 			for (i = 0; i < loops; i++)
+ 			{
+ 				if (write(tmpfile, buf, WRITE_SIZE) != WRITE_SIZE)
+ 					die("write failed");
+ 				if (lseek(tmpfile, 0, SEEK_SET) == -1)
+ 					die("seek failed");
+ 			}
+ 			gettimeofday(&stop_t, NULL);
+ 			close(tmpfile);
+ 			print_elapse(start_t, stop_t);
+ 		}
+ 	}
+ 	else
+ 	{
+ 		printf("\t(unavailable: o_direct)\n");
+ 	}
  #else
  	printf("\t(unavailable: open_datasync)\n");
  #endif
  
+ /*
+  * Test open_sync if available
+  */
  #ifdef OPEN_SYNC_FLAG
  	printf(LABEL_FORMAT, "open_sync 8k write");
  	fflush(stdout);
*************** main(int argc, char *argv[])
*** 135,144 ****
--- 185,226 ----
  	gettimeofday(&stop_t, NULL);
  	close(tmpfile);
  	print_elapse(start_t, stop_t);
+ 
+ 	/*
+ 	 * If O_DIRECT is enabled, test that with open_sync
+ 	 */
+ 	if ( PG_O_DIRECT != 0 )
+ 	{
+ 		printf(LABEL_FORMAT, "open_sync 8k directIO write");
+ 		fflush(stdout);
+ 		if ((tmpfile = open(filename, O_RDWR | O_SYNC | PG_O_DIRECT, 0)) == -1)
+ 			printf("\t(unavailable: o_direct on this filesystem)\n");
+ 		else
+ 		{
+ 			gettimeofday(&start_t, NULL);
+ 			for (i = 0; i < loops; i++)
+ 			{
+ 				if (write(tmpfile, buf, WRITE_SIZE) != WRITE_SIZE)
+ 					die("write failed");
+ 				if (lseek(tmpfile, 0, SEEK_SET) == -1)
+ 					die("seek failed");
+ 			}
+ 			gettimeofday(&stop_t, NULL);
+ 			close(tmpfile);
+ 			print_elapse(start_t, stop_t);
+ 		}
+ 	}
+ 	else
+ 	{
+ 		printf("\t(unavailable: o_direct)\n");
+ 	}
  #else
  	printf("\t(unavailable: open_sync)\n");
  #endif
  
+ /*
+  * Test fdatasync if available
+  */
  #ifdef HAVE_FDATASYNC
  	printf(LABEL_FORMAT, "8k write, fdatasync");
  	fflush(stdout);
*************** main(int argc, char *argv[])
*** 160,165 ****
--- 242,250 ----
  	printf("\t(unavailable: fdatasync)\n");
  #endif
  
+ /*
+  * Test fsync
+  */
  	printf(LABEL_FORMAT, "8k write, fsync");
  	fflush(stdout);
  	if ((tmpfile = open(filename, O_RDWR, 0)) == -1)
*************** main(int argc, char *argv[])
*** 177,188 ****
  	gettimeofday(&stop_t, NULL);
  	close(tmpfile);
  	print_elapse(start_t, stop_t);
  
  	/*
! 	 * Compare file sync methods with two 8k write
  	 */
  	printf("\nCompare file sync methods using two writes:\n");
  
  #ifdef OPEN_DATASYNC_FLAG
  	printf(LABEL_FORMAT, "2 open_datasync 8k writes");
  	fflush(stdout);
--- 262,304 ----
  	gettimeofday(&stop_t, NULL);
  	close(tmpfile);
  	print_elapse(start_t, stop_t);
+ 	
+ /*
+  * If fsync_writethrough is available, test as well
+  * This uses 1/10 the number of loops because it tends
+  * to take forever otherwise.
+  */	
+ #ifdef HAVE_FSYNC_WRITETHROUGH
+ 	printf(LABEL_FORMAT, "8k write, fsync_writethrough");
+ 	fflush(stdout);
+ 	if ((tmpfile = open(filename, O_RDWR, 0)) == -1)
+ 		die("Cannot open output file.");
+ 	gettimeofday(&start_t, NULL);
+ 	for (i = 0; i < writethrough_loops; i++)
+ 	{
+ 		if (write(tmpfile, buf, WRITE_SIZE) != WRITE_SIZE)
+ 			die("write failed");
+ 		if (fcntl(tmpfile, F_FULLFSYNC ) != 0)
+ 			die("fsync failed");
+ 		if (lseek(tmpfile, 0, SEEK_SET) == -1)
+ 			die("seek failed");
+ 	}
+ 	gettimeofday(&stop_t, NULL);
+ 	close(tmpfile);
+ 	print_elapse_writethrough(start_t, stop_t);
+ #else
+ 	printf("\t(unavailable: fsync_writethrough)\n");
+ #endif
  
  	/*
! 	 * Compare some of the file sync methods with 
! 	 * two 8k writes to see if timing is different
  	 */
  	printf("\nCompare file sync methods using two writes:\n");
  
+ /*
+  * Test open_datasync with and without o_direct
+  */
  #ifdef OPEN_DATASYNC_FLAG
  	printf(LABEL_FORMAT, "2 open_datasync 8k writes");
  	fflush(stdout);
*************** main(int argc, char *argv[])
*** 201,210 ****
--- 317,354 ----
  	gettimeofday(&stop_t, NULL);
  	close(tmpfile);
  	print_elapse(start_t, stop_t);
+ 	
+ 	if ( PG_O_DIRECT != 0 ) 
+ 	{
+ 		printf(LABEL_FORMAT, "2 open_datasync directIO 8k writes");
+ 		fflush(stdout);
+ 		if ((tmpfile = open(filename, O_RDWR | O_DSYNC | PG_O_DIRECT, 0)) == -1)
+ 			die("Cannot open output file.");
+ 		gettimeofday(&start_t, NULL);
+ 		for (i = 0; i < loops; i++)
+ 		{
+ 			if (write(tmpfile, buf, WRITE_SIZE) != WRITE_SIZE)
+ 				die("write failed");
+ 			if (write(tmpfile, buf, WRITE_SIZE) != WRITE_SIZE)
+ 				die("write failed");
+ 			if (lseek(tmpfile, 0, SEEK_SET) == -1)
+ 				die("seek failed");
+ 		}
+ 		gettimeofday(&stop_t, NULL);
+ 		close(tmpfile);
+ 		print_elapse(start_t, stop_t);
+ 	}
+ 	else
+ 	{
+ 		printf("\t(unavailable: o_direct)\n");
+ 	}
  #else
  	printf("\t(unavailable: open_datasync)\n");
  #endif
  
+ /*
+  * Test open_sync with and without o_direct
+  */
  #ifdef OPEN_SYNC_FLAG
  	printf(LABEL_FORMAT, "2 open_sync 8k writes");
  	fflush(stdout);
*************** main(int argc, char *argv[])
*** 223,230 ****
--- 367,404 ----
  	gettimeofday(&stop_t, NULL);
  	close(tmpfile);
  	print_elapse(start_t, stop_t);
+ 	
+ 		if ( PG_O_DIRECT != 0 ) 
+ 	{
+ 		printf(LABEL_FORMAT, "2 open_sync directIO 8k writes");
+ 		fflush(stdout);
+ 		if ((tmpfile = open(filename, O_RDWR | O_SYNC | PG_O_DIRECT, 0)) == -1)
+ 			die("Cannot open output file.");
+ 		gettimeofday(&start_t, NULL);
+ 		for (i = 0; i < loops; i++)
+ 		{
+ 			if (write(tmpfile, buf, WRITE_SIZE) != WRITE_SIZE)
+ 				die("write failed");
+ 			if (write(tmpfile, buf, WRITE_SIZE) != WRITE_SIZE)
+ 				die("write failed");
+ 			if (lseek(tmpfile, 0, SEEK_SET) == -1)
+ 				die("seek failed");
+ 		}
+ 		gettimeofday(&stop_t, NULL);
+ 		close(tmpfile);
+ 		print_elapse(start_t, stop_t);
+ 	}
+ 	else
+ 	{
+ 		printf("\t(unavailable: o_direct)\n");
+ 	}
+ #else
+ 	printf("\t(unavailable: open_sync)\n");
  #endif
  
+ /*
+  *	Test fdatasync
+  */
  #ifdef HAVE_FDATASYNC
  	printf(LABEL_FORMAT, "8k write, 8k write, fdatasync");
  	fflush(stdout);
*************** main(int argc, char *argv[])
*** 248,253 ****
--- 422,430 ----
  	printf("\t(unavailable: fdatasync)\n");
  #endif
  
+ /*
+  * Test basic fsync
+  */
  	printf(LABEL_FORMAT, "8k write, 8k write, fsync");
  	fflush(stdout);
  	if ((tmpfile = open(filename, O_RDWR, 0)) == -1)
*************** main(int argc, char *argv[])
*** 267,278 ****
--- 444,488 ----
  	gettimeofday(&stop_t, NULL);
  	close(tmpfile);
  	print_elapse(start_t, stop_t);
+ 	
+ /*
+  * Test fsync_writethrough if available
+  * Again, using 1/10 as many loops
+  */	
+ #ifdef HAVE_FSYNC_WRITETHROUGH
+ 	printf(LABEL_FORMAT, "8k write, 8k write, fsync_writethrough");
+ 	fflush(stdout);
+ 	if ((tmpfile = open(filename, O_RDWR, 0)) == -1)
+ 		die("Cannot open output file.");
+ 	gettimeofday(&start_t, NULL);
+ 	for (i = 0; i < writethrough_loops; i++)
+ 	{
+ 		if (write(tmpfile, buf, WRITE_SIZE) != WRITE_SIZE)
+ 			die("write failed");
+ 		if (write(tmpfile, buf, WRITE_SIZE) != WRITE_SIZE)
+ 			die("write failed");
+ 		if (fcntl(tmpfile, F_FULLFSYNC) != 0)
+ 			die("fsync failed");
+ 		if (lseek(tmpfile, 0, SEEK_SET) == -1)
+ 			die("seek failed");
+ 	}
+ 	gettimeofday(&stop_t, NULL);
+ 	close(tmpfile);
+ 	print_elapse_writethrough(start_t, stop_t);
+ #else
+ 	printf("\t(unavailable: fsync_writethrough)\n");
+ #endif
  
  	/*
  	 * Compare 1 to 2 writes
  	 */
  	printf("\nCompare open_sync with different sizes:\n");
  
+ /*
+  * Test open_sync with different size files
+  * It's unclear why this is in test_fsync, since it's 
+  * not anything PostgreSQL does
+  */
  #ifdef OPEN_SYNC_FLAG
  	printf(LABEL_FORMAT, "open_sync 16k write");
  	fflush(stdout);
*************** main(int argc, char *argv[])
*** 312,323 ****
  #endif
  
  	/*
! 	 * Fsync another file descriptor?
  	 */
  	printf("\nTest if fsync on non-write file descriptor is honored:\n");
  	printf("(If the times are similar, fsync() can sync data written\n");
  	printf("on a different descriptor.)\n");
  
  	printf(LABEL_FORMAT, "8k write, fsync, close");
  	fflush(stdout);
  	gettimeofday(&start_t, NULL);
--- 522,541 ----
  #endif
  
  	/*
! 	 * Test whether fsync can sync data written on a different
! 	 * descriptor for the same file.  This checks the efficiency
! 	 * of multi-process fsyncs against the same file.
! 	 * Possibly this should be done with writethrough on platforms
! 	 * which support it.
  	 */
  	printf("\nTest if fsync on non-write file descriptor is honored:\n");
  	printf("(If the times are similar, fsync() can sync data written\n");
  	printf("on a different descriptor.)\n");
  
+ 	/* 
+ 	 * first write, fsync and close, which is the 
+ 	 * normal behavior without multiple descriptors
+ 	 */
  	printf(LABEL_FORMAT, "8k write, fsync, close");
  	fflush(stdout);
  	gettimeofday(&start_t, NULL);
*************** main(int argc, char *argv[])
*** 330,343 ****
  		if (fsync(tmpfile) != 0)
  			die("fsync failed");
  		close(tmpfile);
  		if ((tmpfile = open(filename, O_RDWR, 0)) == -1)
  			die("Cannot open output file.");
- 		/* do nothing but the open/close the tests are consistent. */
  		close(tmpfile);
  	}
  	gettimeofday(&stop_t, NULL);
  	print_elapse(start_t, stop_t);
  
   	printf(LABEL_FORMAT, "8k write, close, fsync");
   	fflush(stdout);
  	gettimeofday(&start_t, NULL);
--- 548,569 ----
  		if (fsync(tmpfile) != 0)
  			die("fsync failed");
  		close(tmpfile);
+ 		/*
+ 		 * open and close the file again to be consistent
+ 		 * with the following test
+ 		 */
  		if ((tmpfile = open(filename, O_RDWR, 0)) == -1)
  			die("Cannot open output file.");
  		close(tmpfile);
  	}
  	gettimeofday(&stop_t, NULL);
  	print_elapse(start_t, stop_t);
  
+ 	/*
+ 	 * Now open, write, close, open again and fsync
+ 	 * This simulates processes fsyncing each other's
+ 	 * writes.
+ 	 */
   	printf(LABEL_FORMAT, "8k write, close, fsync");
   	fflush(stdout);
  	gettimeofday(&start_t, NULL);
*************** main(int argc, char *argv[])
*** 358,381 ****
  	gettimeofday(&stop_t, NULL);
  	print_elapse(start_t, stop_t);
  
! 	/* cleanup */
  	free(full_buf);
  	unlink(filename);
  
  	return 0;
  }
  
  void
  print_elapse(struct timeval start_t, struct timeval stop_t)
  {
  	double		total_time = (stop_t.tv_sec - start_t.tv_sec) +
- 	/* usec subtraction might be negative, e.g. 5.4 - 4.8 */
  	(stop_t.tv_usec - start_t.tv_usec) * 0.000001;
  	double		per_second = loops / total_time;
  
  	printf("%9.3f/second\n", per_second);
  }
  
  void
  die(char *str)
  {
--- 584,624 ----
  	gettimeofday(&stop_t, NULL);
  	print_elapse(start_t, stop_t);
  
! 	/* 
! 	 * cleanup 
! 	 */
  	free(full_buf);
  	unlink(filename);
  
  	return 0;
  }
  
+ /* 
+  * print out the writes per second for most tests
+  */
  void
  print_elapse(struct timeval start_t, struct timeval stop_t)
  {
  	double		total_time = (stop_t.tv_sec - start_t.tv_sec) +
  	(stop_t.tv_usec - start_t.tv_usec) * 0.000001;
  	double		per_second = loops / total_time;
  
  	printf("%9.3f/second\n", per_second);
  }
  
+ /* 
+  * print out the writes per second for writethrough tests
+  */
+ void
+ print_elapse_writethrough(struct timeval start_t, struct timeval stop_t)
+ {
+ 	double		total_time = (stop_t.tv_sec - start_t.tv_sec) +
+ 	(stop_t.tv_usec - start_t.tv_usec) * 0.000001;
+ 	double		per_second = writethrough_loops / total_time;
+ 
+ 	printf("%9.3f/second\n", per_second);
+ }
+ 
  void
  die(char *str)
  {

diff --git a/src/tools/fsync/Makefile b/src/tools/fsync/Makefile
index fe3e626..44419ee 100644
*** /tmp/pgdiff.17122/M3047c_Makefile	Sat Jan 15 11:53:43 2011
--- src/tools/fsync/Makefile	Fri Jan 14 22:35:30 2011
*************** override CPPFLAGS := -I$(libpq_srcdir) $
*** 16,24 ****
  
  OBJS= test_fsync.o
  
! all: test_fsync
  
! test_fsync: test_fsync.o | submake-libpq submake-libpgport
  	$(CC) $(CFLAGS) test_fsync.o $(libpq_pgport) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X)
  
  clean distclean maintainer-clean:
--- 16,24 ----
  
  OBJS= test_fsync.o
  
! all: submake-libpq submake-libpgport test_fsync
  
! test_fsync: test_fsync.o $(libpq_builddir)/libpq.a
  	$(CC) $(CFLAGS) test_fsync.o $(libpq_pgport) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X)
  
  clean distclean maintainer-clean:
diff --git a/src/tools/fsync/README b/src/tools/fsync/README
index 6d9acd3..a1c2ae4 100644
*** /tmp/pgdiff.17122/wFeqrc_README	Sat Jan 15 11:53:43 2011
--- src/tools/fsync/README	Sat Jan 15 11:34:58 2011
***************
*** 1,11 ****
! src/tools/fsync/README
! 
! fsync
! =====
  
  This program tests fsync.  The tests are described as part of the program output.
  
  	Usage:	test_fsync [-f filename] [loops]
  
- Loops defaults to 5000.  The default output file is /var/tmp/test_fsync.out.
- Consider that /tmp or /var/tmp might be memory-based file systems.
--- 1,20 ----
! test_fsync
! ==========
  
  This program tests fsync.  The tests are described as part of the program output.
  
  	Usage:	test_fsync [-f filename] [loops]
+ 	
+ test_fsync is intended to give you a reasonable idea of what the fastest
+ fsync_method is on your specific system, as well as supplying diagnostic
+ information in the event of an identified I/O problem.  However,
+ differences shown by test_fsync might not make any difference in real
+ database throughput, especially since many database servers are not
+ speed-limited by their transaction logs.
+ 
+ The output filename defaults to test_fsync.out in the current directory.
+ test_fsync should be run in the same filesystem as your transaction log
+ directory (pg_xlog).
+ 
+ Loops default to 2000.  Increase this to get more accurate measurements.
  
diff --git a/src/tools/fsync/test_fsync.c b/src/tools/fsync/test_fsync.c
index 28c2119..831e2a0 100644
*** /tmp/pgdiff.17122/OSeljb_test_fsync.c	Sat Jan 15 11:53:43 2011
--- src/tools/fsync/test_fsync.c	Sat Jan 15 11:52:03 2011
***************
*** 3,9 ****
   *
   *
   *	test_fsync.c
!  *		test various fsync() methods
   */
  
  #include "postgres.h"
--- 3,9 ----
   *
   *
   *	test_fsync.c
!  *		tests all supported fsync() methods
   */
  
  #include "postgres.h"
***************
*** 22,40 ****
  #include <unistd.h>
  #include <string.h>
  
! 
! #ifdef WIN32
  #define FSYNC_FILENAME	"./test_fsync.out"
- #else
- /* /tmp might be a memory file system */
- #define FSYNC_FILENAME	"/var/tmp/test_fsync.out"
- #endif
  
  #define WRITE_SIZE	(8 * 1024)	/* 8k */
  
  #define LABEL_FORMAT	"\t%-30s"
  
! int			loops = 10000;
  
  void		die(char *str);
  void		print_elapse(struct timeval start_t, struct timeval stop_t);
--- 22,39 ----
  #include <unistd.h>
  #include <string.h>
  
! /* 
!  * put the temp files in the local directory
!  * unless the user specifies otherwise 
!  */
  #define FSYNC_FILENAME	"./test_fsync.out"
  
  #define WRITE_SIZE	(8 * 1024)	/* 8k */
  
  #define LABEL_FORMAT	"\t%-30s"
  
! 
! int			loops = 2000;
  
  void		die(char *str);
  void		print_elapse(struct timeval start_t, struct timeval stop_t);
*************** void		print_elapse(struct timeval start_
*** 42,55 ****
  int
  main(int argc, char *argv[])
  {
! 	struct timeval start_t;
! 	struct timeval stop_t;
! 	int			tmpfile,
! 				i;
  	char	   *full_buf = (char *) malloc(XLOG_SEG_SIZE),
! 			   *buf;
! 	char	   *filename = FSYNC_FILENAME;
  
  	if (argc > 2 && strcmp(argv[1], "-f") == 0)
  	{
  		filename = argv[2];
--- 41,54 ----
  int
  main(int argc, char *argv[])
  {
! 	struct timeval start_t, stop_t;
! 	int			tmpfile, i;
  	char	   *full_buf = (char *) malloc(XLOG_SEG_SIZE),
! 			   *buf, *filename = FSYNC_FILENAME;
  
+ 	/* 
+ 	 * arguments: loops and filename (optional) 
+ 	 */
  	if (argc > 2 && strcmp(argv[1], "-f") == 0)
  	{
  		filename = argv[2];
*************** main(int argc, char *argv[])
*** 57,73 ****
  		argc -= 2;
  	}
  
! 	if (argc > 1)
  		loops = atoi(argv[1]);
  
  	for (i = 0; i < XLOG_SEG_SIZE; i++)
  		full_buf[i] = random();
  
  	if ((tmpfile = open(filename, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR)) == -1)
  		die("Cannot open output file.");
  	if (write(tmpfile, full_buf, XLOG_SEG_SIZE) != XLOG_SEG_SIZE)
  		die("write failed");
! 	/* fsync now so later fsync's don't have to do it */
  	if (fsync(tmpfile) != 0)
  		die("fsync failed");
  	close(tmpfile);
--- 56,77 ----
  		argc -= 2;
  	}
  
! 	if (argc > 1) 
  		loops = atoi(argv[1]);
  
  	for (i = 0; i < XLOG_SEG_SIZE; i++)
  		full_buf[i] = random();
  
+ 	/* 
+ 	 * test if we can open the target file 
+ 	 */
  	if ((tmpfile = open(filename, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR)) == -1)
  		die("Cannot open output file.");
  	if (write(tmpfile, full_buf, XLOG_SEG_SIZE) != XLOG_SEG_SIZE)
  		die("write failed");
! 	/*
! 	 * fsync now so that dirty buffers don't skew later tests
! 	 */
  	if (fsync(tmpfile) != 0)
  		die("fsync failed");
  	close(tmpfile);
*************** main(int argc, char *argv[])
*** 77,83 ****
  	printf("Loops = %d\n\n", loops);
  
  	/*
! 	 * Simple write
  	 */
  	printf("Simple write:\n");
  	printf(LABEL_FORMAT, "8k write");
--- 81,87 ----
  	printf("Loops = %d\n\n", loops);
  
  	/*
! 	 * Test a simple write without fsync
  	 */
  	printf("Simple write:\n");
  	printf(LABEL_FORMAT, "8k write");
*************** main(int argc, char *argv[])
*** 95,104 ****
  	print_elapse(start_t, stop_t);
  
  	/*
! 	 * Compare file sync methods with one 8k write
  	 */
  	printf("\nCompare file sync methods using one write:\n");
  
  #ifdef OPEN_DATASYNC_FLAG
  	printf(LABEL_FORMAT, "open_datasync 8k write");
  	fflush(stdout);
--- 99,111 ----
  	print_elapse(start_t, stop_t);
  
  	/*
! 	 * Test all fsync methods using single 8k writes
  	 */
  	printf("\nCompare file sync methods using one write:\n");
  
+ 	/*
+ 	 * Test open_datasync if available
+ 	 */
  #ifdef OPEN_DATASYNC_FLAG
  	printf(LABEL_FORMAT, "open_datasync 8k write");
  	fflush(stdout);
*************** main(int argc, char *argv[])
*** 115,124 ****
--- 122,161 ----
  	gettimeofday(&stop_t, NULL);
  	close(tmpfile);
  	print_elapse(start_t, stop_t);
+ 
+ 	/*
+ 	 * If O_DIRECT is enabled, test that with open_datasync
+ 	 */
+ #if PG_O_DIRECT != 0
+ 	fflush(stdout);
+ 	if ((tmpfile = open(filename, O_RDWR | O_DSYNC | PG_O_DIRECT, 0)) == -1)
+ 		printf("\t(unavailable: o_direct on this filesystem)\n");
+ 	else
+ 	{
+ 		printf(LABEL_FORMAT, "open_datasync 8k direct I/O write");
+ 		gettimeofday(&start_t, NULL);
+ 		for (i = 0; i < loops; i++)
+ 		{
+ 			if (write(tmpfile, buf, WRITE_SIZE) != WRITE_SIZE)
+ 				die("write failed");
+ 			if (lseek(tmpfile, 0, SEEK_SET) == -1)
+ 				die("seek failed");
+ 		}
+ 		gettimeofday(&stop_t, NULL);
+ 		close(tmpfile);
+ 		print_elapse(start_t, stop_t);
+ 	}
+ #else
+ 		printf("\t(unavailable: o_direct)\n");
+ #endif
+ 
  #else
  	printf("\t(unavailable: open_datasync)\n");
  #endif
  
+ /*
+  * Test open_sync if available
+  */
  #ifdef OPEN_SYNC_FLAG
  	printf(LABEL_FORMAT, "open_sync 8k write");
  	fflush(stdout);
*************** main(int argc, char *argv[])
*** 135,144 ****
--- 172,211 ----
  	gettimeofday(&stop_t, NULL);
  	close(tmpfile);
  	print_elapse(start_t, stop_t);
+ 
+ 	/*
+ 	 * If O_DIRECT is enabled, test that with open_sync
+ 	 */
+ #if PG_O_DIRECT != 0
+ 	printf(LABEL_FORMAT, "open_sync 8k direct I/O write");
+ 	fflush(stdout);
+ 	if ((tmpfile = open(filename, O_RDWR | OPEN_SYNC_FLAG | PG_O_DIRECT, 0)) == -1)
+ 		printf("\t(unavailable: o_direct on this filesystem)\n");
+ 	else
+ 	{
+ 		gettimeofday(&start_t, NULL);
+ 		for (i = 0; i < loops; i++)
+ 		{
+ 			if (write(tmpfile, buf, WRITE_SIZE) != WRITE_SIZE)
+ 				die("write failed");
+ 			if (lseek(tmpfile, 0, SEEK_SET) == -1)
+ 				die("seek failed");
+ 		}
+ 		gettimeofday(&stop_t, NULL);
+ 		close(tmpfile);
+ 		print_elapse(start_t, stop_t);
+ 	}
+ #else
+ 	printf("\t(unavailable: o_direct)\n");
+ #endif
+ 
  #else
  	printf("\t(unavailable: open_sync)\n");
  #endif
  
+ /*
+  * Test fdatasync if available
+  */
  #ifdef HAVE_FDATASYNC
  	printf(LABEL_FORMAT, "8k write, fdatasync");
  	fflush(stdout);
*************** main(int argc, char *argv[])
*** 160,165 ****
--- 227,235 ----
  	printf("\t(unavailable: fdatasync)\n");
  #endif
  
+ /*
+  * Test fsync
+  */
  	printf(LABEL_FORMAT, "8k write, fsync");
  	fflush(stdout);
  	if ((tmpfile = open(filename, O_RDWR, 0)) == -1)
*************** main(int argc, char *argv[])
*** 177,190 ****
  	gettimeofday(&stop_t, NULL);
  	close(tmpfile);
  	print_elapse(start_t, stop_t);
  
  	/*
! 	 * Compare file sync methods with two 8k write
  	 */
  	printf("\nCompare file sync methods using two writes:\n");
  
  #ifdef OPEN_DATASYNC_FLAG
! 	printf(LABEL_FORMAT, "2 open_datasync 8k writes");
  	fflush(stdout);
  	if ((tmpfile = open(filename, O_RDWR | O_DSYNC, 0)) == -1)
  		die("Cannot open output file.");
--- 247,289 ----
  	gettimeofday(&stop_t, NULL);
  	close(tmpfile);
  	print_elapse(start_t, stop_t);
+ 	
+ /*
+  * If fsync_writethrough is available, test as well
+  */	
+ #ifdef HAVE_FSYNC_WRITETHROUGH
+ 	printf(LABEL_FORMAT, "8k write, fsync_writethrough");
+ 	fflush(stdout);
+ 	if ((tmpfile = open(filename, O_RDWR, 0)) == -1)
+ 		die("Cannot open output file.");
+ 	gettimeofday(&start_t, NULL);
+ 	for (i = 0; i < loops; i++)
+ 	{
+ 		if (write(tmpfile, buf, WRITE_SIZE) != WRITE_SIZE)
+ 			die("write failed");
+ 		if (fcntl(tmpfile, F_FULLFSYNC ) != 0)
+ 			die("fsync failed");
+ 		if (lseek(tmpfile, 0, SEEK_SET) == -1)
+ 			die("seek failed");
+ 	}
+ 	gettimeofday(&stop_t, NULL);
+ 	close(tmpfile);
+ 	print_elapse(start_t, stop_t);
+ #else
+ 	printf("\t(unavailable: fsync_writethrough)\n");
+ #endif
  
  	/*
! 	 * Compare some of the file sync methods with 
! 	 * two 8k writes to see if timing is different
  	 */
  	printf("\nCompare file sync methods using two writes:\n");
  
+ /*
+  * Test open_datasync with and without o_direct
+  */
  #ifdef OPEN_DATASYNC_FLAG
!  	printf(LABEL_FORMAT, "2 open_datasync 8k writes");
  	fflush(stdout);
  	if ((tmpfile = open(filename, O_RDWR | O_DSYNC, 0)) == -1)
  		die("Cannot open output file.");
*************** main(int argc, char *argv[])
*** 201,210 ****
--- 300,335 ----
  	gettimeofday(&stop_t, NULL);
  	close(tmpfile);
  	print_elapse(start_t, stop_t);
+ 	
+ #if PG_O_DIRECT != 0
+ 	printf(LABEL_FORMAT, "2 open_datasync direct I/O 8k writes");
+ 	fflush(stdout);
+ 	if ((tmpfile = open(filename, O_RDWR | O_DSYNC | PG_O_DIRECT, 0)) == -1)
+ 		die("Cannot open output file.");
+ 	gettimeofday(&start_t, NULL);
+ 	for (i = 0; i < loops; i++)
+ 	{
+ 		if (write(tmpfile, buf, WRITE_SIZE) != WRITE_SIZE)
+ 			die("write failed");
+ 		if (write(tmpfile, buf, WRITE_SIZE) != WRITE_SIZE)
+ 			die("write failed");
+ 		if (lseek(tmpfile, 0, SEEK_SET) == -1)
+ 			die("seek failed");
+ 	}
+ 	gettimeofday(&stop_t, NULL);
+ 	close(tmpfile);
+ 	print_elapse(start_t, stop_t);
+ #else
+ 		printf("\t(unavailable: o_direct)\n");
+ #endif
+ 
  #else
  	printf("\t(unavailable: open_datasync)\n");
  #endif
  
+ /*
+  * Test open_sync with and without o_direct
+  */
  #ifdef OPEN_SYNC_FLAG
  	printf(LABEL_FORMAT, "2 open_sync 8k writes");
  	fflush(stdout);
*************** main(int argc, char *argv[])
*** 223,230 ****
--- 348,383 ----
  	gettimeofday(&stop_t, NULL);
  	close(tmpfile);
  	print_elapse(start_t, stop_t);
+ 	
+ #if PG_O_DIRECT != 0
+ 	printf(LABEL_FORMAT, "2 open_sync direct I/O 8k writes");
+ 	fflush(stdout);
+ 	if ((tmpfile = open(filename, O_RDWR | OPEN_SYNC_FLAG | PG_O_DIRECT, 0)) == -1)
+ 		die("Cannot open output file.");
+ 	gettimeofday(&start_t, NULL);
+ 	for (i = 0; i < loops; i++)
+ 	{
+ 		if (write(tmpfile, buf, WRITE_SIZE) != WRITE_SIZE)
+ 			die("write failed");
+ 		if (write(tmpfile, buf, WRITE_SIZE) != WRITE_SIZE)
+ 			die("write failed");
+ 		if (lseek(tmpfile, 0, SEEK_SET) == -1)
+ 			die("seek failed");
+ 	}
+ 	gettimeofday(&stop_t, NULL);
+ 	close(tmpfile);
+ 	print_elapse(start_t, stop_t);
+ #else
+ 	printf("\t(unavailable: o_direct)\n");
+ #endif
+ 
+ #else
+ 	printf("\t(unavailable: open_sync)\n");
  #endif
  
+ /*
+  *	Test fdatasync
+  */
  #ifdef HAVE_FDATASYNC
  	printf(LABEL_FORMAT, "8k write, 8k write, fdatasync");
  	fflush(stdout);
*************** main(int argc, char *argv[])
*** 248,253 ****
--- 401,409 ----
  	printf("\t(unavailable: fdatasync)\n");
  #endif
  
+ /*
+  * Test basic fsync
+  */
  	printf(LABEL_FORMAT, "8k write, 8k write, fsync");
  	fflush(stdout);
  	if ((tmpfile = open(filename, O_RDWR, 0)) == -1)
*************** main(int argc, char *argv[])
*** 267,278 ****
--- 423,466 ----
  	gettimeofday(&stop_t, NULL);
  	close(tmpfile);
  	print_elapse(start_t, stop_t);
+ 	
+ /*
+  * Test fsync_writethrough if available
+  */	
+ #ifdef HAVE_FSYNC_WRITETHROUGH
+ 	printf(LABEL_FORMAT, "8k write, 8k write, fsync_writethrough");
+ 	fflush(stdout);
+ 	if ((tmpfile = open(filename, O_RDWR, 0)) == -1)
+ 		die("Cannot open output file.");
+ 	gettimeofday(&start_t, NULL);
+ 	for (i = 0; i < loops; i++)
+ 	{
+ 		if (write(tmpfile, buf, WRITE_SIZE) != WRITE_SIZE)
+ 			die("write failed");
+ 		if (write(tmpfile, buf, WRITE_SIZE) != WRITE_SIZE)
+ 			die("write failed");
+ 		if (fcntl(tmpfile, F_FULLFSYNC) != 0)
+ 			die("fsync failed");
+ 		if (lseek(tmpfile, 0, SEEK_SET) == -1)
+ 			die("seek failed");
+ 	}
+ 	gettimeofday(&stop_t, NULL);
+ 	close(tmpfile);
+ 	print_elapse(start_t, stop_t);
+ #else
+ 	printf("\t(unavailable: fsync_writethrough)\n");
+ #endif
  
  	/*
  	 * Compare 1 to 2 writes
  	 */
  	printf("\nCompare open_sync with different sizes:\n");
+ 	printf("(This is designed to compare the cost of one large\n");
+ 	printf("sync'ed write and two smaller sync'ed writes.)\n");
  
+ /*
+  * Test open_sync with different size files
+  */
  #ifdef OPEN_SYNC_FLAG
  	printf(LABEL_FORMAT, "open_sync 16k write");
  	fflush(stdout);
*************** main(int argc, char *argv[])
*** 312,323 ****
  #endif
  
  	/*
! 	 * Fsync another file descriptor?
  	 */
  	printf("\nTest if fsync on non-write file descriptor is honored:\n");
  	printf("(If the times are similar, fsync() can sync data written\n");
  	printf("on a different descriptor.)\n");
  
  	printf(LABEL_FORMAT, "8k write, fsync, close");
  	fflush(stdout);
  	gettimeofday(&start_t, NULL);
--- 500,519 ----
  #endif
  
  	/*
! 	 * Test whether fsync can sync data written on a different
! 	 * descriptor for the same file.  This checks the efficiency
! 	 * of multi-process fsyncs against the same file.
! 	 * Possibly this should be done with writethrough on platforms
! 	 * which support it.
  	 */
  	printf("\nTest if fsync on non-write file descriptor is honored:\n");
  	printf("(If the times are similar, fsync() can sync data written\n");
  	printf("on a different descriptor.)\n");
  
+ 	/* 
+ 	 * first write, fsync and close, which is the 
+ 	 * normal behavior without multiple descriptors
+ 	 */
  	printf(LABEL_FORMAT, "8k write, fsync, close");
  	fflush(stdout);
  	gettimeofday(&start_t, NULL);
*************** main(int argc, char *argv[])
*** 330,343 ****
  		if (fsync(tmpfile) != 0)
  			die("fsync failed");
  		close(tmpfile);
  		if ((tmpfile = open(filename, O_RDWR, 0)) == -1)
  			die("Cannot open output file.");
- 		/* do nothing but the open/close the tests are consistent. */
  		close(tmpfile);
  	}
  	gettimeofday(&stop_t, NULL);
  	print_elapse(start_t, stop_t);
  
   	printf(LABEL_FORMAT, "8k write, close, fsync");
   	fflush(stdout);
  	gettimeofday(&start_t, NULL);
--- 526,547 ----
  		if (fsync(tmpfile) != 0)
  			die("fsync failed");
  		close(tmpfile);
+ 		/*
+ 		 * open and close the file again to be consistent
+ 		 * with the following test
+ 		 */
  		if ((tmpfile = open(filename, O_RDWR, 0)) == -1)
  			die("Cannot open output file.");
  		close(tmpfile);
  	}
  	gettimeofday(&stop_t, NULL);
  	print_elapse(start_t, stop_t);
  
+ 	/*
+ 	 * Now open, write, close, open again and fsync
+ 	 * This simulates processes fsyncing each other's
+ 	 * writes.
+ 	 */
   	printf(LABEL_FORMAT, "8k write, close, fsync");
   	fflush(stdout);
  	gettimeofday(&start_t, NULL);
*************** main(int argc, char *argv[])
*** 358,375 ****
  	gettimeofday(&stop_t, NULL);
  	print_elapse(start_t, stop_t);
  
! 	/* cleanup */
  	free(full_buf);
  	unlink(filename);
  
  	return 0;
  }
  
  void
  print_elapse(struct timeval start_t, struct timeval stop_t)
  {
  	double		total_time = (stop_t.tv_sec - start_t.tv_sec) +
- 	/* usec subtraction might be negative, e.g. 5.4 - 4.8 */
  	(stop_t.tv_usec - start_t.tv_usec) * 0.000001;
  	double		per_second = loops / total_time;
  
--- 562,583 ----
  	gettimeofday(&stop_t, NULL);
  	print_elapse(start_t, stop_t);
  
! 	/* 
! 	 * cleanup 
! 	 */
  	free(full_buf);
  	unlink(filename);
  
  	return 0;
  }
  
+ /* 
+  * print out the writes per second for tests
+  */
  void
  print_elapse(struct timeval start_t, struct timeval stop_t)
  {
  	double		total_time = (stop_t.tv_sec - start_t.tv_sec) +
  	(stop_t.tv_usec - start_t.tv_usec) * 0.000001;
  	double		per_second = loops / total_time;