pg_receivexlog --status-interval add fsync feedback

*** a/doc/src/sgml/ref/pg_receivexlog.sgml
--- b/doc/src/sgml/ref/pg_receivexlog.sgml
***************
*** 196,201 **** PostgreSQL documentation
--- 196,211 ----
       </varlistentry>
  
       <varlistentry>
+       <term><option>-r</></term>
+       <term><option>--reply-fsync</></term>
+       <listitem>
+        <para>
+         status packets sent to server as soon as after fsync.
+        </para>
+       </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
        <term><option>-U <replaceable>username</replaceable></option></term>
        <term><option>--username=<replaceable class="parameter">username</replaceable></option></term>
        <listitem>
*** a/src/bin/pg_basebackup/pg_basebackup.c
--- b/src/bin/pg_basebackup/pg_basebackup.c
***************
*** 371,377 **** LogStreamerMain(logstreamer_param *param)
  	if (!ReceiveXlogStream(param->bgconn, param->startptr, param->timeline,
  						   param->sysidentifier, param->xlogdir,
  						   reached_end_position, standby_message_timeout,
! 						   NULL, 0))
  
  		/*
  		 * Any errors will already have been reported in the function process,
--- 371,377 ----
  	if (!ReceiveXlogStream(param->bgconn, param->startptr, param->timeline,
  						   param->sysidentifier, param->xlogdir,
  						   reached_end_position, standby_message_timeout,
! 						   NULL, 0, false))
  
  		/*
  		 * Any errors will already have been reported in the function process,
*** a/src/bin/pg_basebackup/pg_receivexlog.c
--- b/src/bin/pg_basebackup/pg_receivexlog.c
***************
*** 38,44 **** static int	noloop = 0;
  static int	standby_message_timeout = 10 * 1000;		/* 10 sec = default */
  static int	fsync_interval = 0; /* 0 = default */
  static volatile bool time_to_abort = false;
! 
  
  static void usage(void);
  static XLogRecPtr FindStreamingStart(uint32 *tli);
--- 38,44 ----
  static int	standby_message_timeout = 10 * 1000;		/* 10 sec = default */
  static int	fsync_interval = 0; /* 0 = default */
  static volatile bool time_to_abort = false;
! static volatile bool reply_fsync = false;
  
  static void usage(void);
  static XLogRecPtr FindStreamingStart(uint32 *tli);
***************
*** 74,79 **** usage(void)
--- 74,80 ----
  	printf(_("  -p, --port=PORT        database server port number\n"));
  	printf(_("  -s, --status-interval=INTERVAL\n"
  			 "                         time between status packets sent to server (in seconds)\n"));
+ 	printf(_("  -r, --reply-fsync      status packets sent to server as soon as after fsync\n"));
  	printf(_("  -U, --username=NAME    connect as specified database user\n"));
  	printf(_("  -w, --no-password      never prompt for password\n"));
  	printf(_("  -W, --password         force password prompt (should happen automatically)\n"));
***************
*** 334,340 **** StreamLog(void)
  
  	ReceiveXlogStream(conn, startpos, starttli, NULL, basedir,
  					  stop_streaming, standby_message_timeout, ".partial",
! 					  fsync_interval);
  
  	PQfinish(conn);
  }
--- 335,341 ----
  
  	ReceiveXlogStream(conn, startpos, starttli, NULL, basedir,
  					  stop_streaming, standby_message_timeout, ".partial",
! 					  fsync_interval, reply_fsync);
  
  	PQfinish(conn);
  }
***************
*** 368,373 **** main(int argc, char **argv)
--- 369,375 ----
  		{"no-password", no_argument, NULL, 'w'},
  		{"password", no_argument, NULL, 'W'},
  		{"status-interval", required_argument, NULL, 's'},
+ 		{"reply-fsync", no_argument, NULL, 'r'},
  		{"slot", required_argument, NULL, 'S'},
  		{"verbose", no_argument, NULL, 'v'},
  		{NULL, 0, NULL, 0}
***************
*** 394,400 **** main(int argc, char **argv)
  		}
  	}
  
! 	while ((c = getopt_long(argc, argv, "D:d:h:p:U:s:S:nF:wWv",
  							long_options, &option_index)) != -1)
  	{
  		switch (c)
--- 396,402 ----
  		}
  	}
  
! 	while ((c = getopt_long(argc, argv, "D:d:h:p:U:s:rS:nF:wWv",
  							long_options, &option_index)) != -1)
  	{
  		switch (c)
***************
*** 435,440 **** main(int argc, char **argv)
--- 437,445 ----
  					exit(1);
  				}
  				break;
+ 			case 'r':
+ 				reply_fsync = true;
+ 				break;
  			case 'S':
  				replication_slot = pg_strdup(optarg);
  				break;
*** a/src/bin/pg_basebackup/receivelog.c
--- b/src/bin/pg_basebackup/receivelog.c
***************
*** 33,65 **** static XLogRecPtr lastFlushPosition = InvalidXLogRecPtr;
  
  static int64 last_fsync = -1;		/* timestamp of last WAL file flush */
  static bool still_sending = true;		/* feedback still needs to be sent? */
  
  static PGresult *HandleCopyStream(PGconn *conn, XLogRecPtr startpos,
  				 uint32 timeline, char *basedir,
  			   stream_stop_callback stream_stop, int standby_message_timeout,
  				  char *partial_suffix, XLogRecPtr *stoppos,
! 				  int fsync_interval);
  static int CopyStreamPoll(PGconn *conn, long timeout_ms);
  static int CopyStreamReceive(PGconn *conn, long timeout, char **buffer);
  static bool ProcessKeepaliveMsg(PGconn *conn, char *copybuf, int len,
! 								XLogRecPtr blockpos, int64 *last_status);
  static bool ProcessXLogDataMsg(PGconn *conn, char *copybuf, int len,
  							   XLogRecPtr *blockpos, uint32 timeline,
  							   char *basedir, stream_stop_callback stream_stop,
! 							   char *partial_suffix);
  static PGresult *HandleEndOfCopyStream(PGconn *conn, char *copybuf,
  									   XLogRecPtr blockpos, char *basedir, char *partial_suffix,
! 									   XLogRecPtr *stoppos);
  static bool CheckCopyStreamStop(PGconn *conn, XLogRecPtr blockpos,
  								uint32 timeline, char *basedir,
  								stream_stop_callback stream_stop,
! 								char *partial_suffix, XLogRecPtr *stoppos);
  static long CalculateCopyStreamSleeptime(int64 now, int standby_message_timeout,
! 										 int64 last_status, int fsync_interval,
  										 XLogRecPtr blockpos);
  
  static bool ReadEndOfStreamingResult(PGresult *res, XLogRecPtr *startpos,
  						 uint32 *timeline);
  
  /*
   * Open a new WAL file in the specified directory.
--- 33,69 ----
  
  static int64 last_fsync = -1;		/* timestamp of last WAL file flush */
  static bool still_sending = true;		/* feedback still needs to be sent? */
+ static int64 last_status = -1;		/* timestamp of last feedback message */
  
  static PGresult *HandleCopyStream(PGconn *conn, XLogRecPtr startpos,
  				 uint32 timeline, char *basedir,
  			   stream_stop_callback stream_stop, int standby_message_timeout,
  				  char *partial_suffix, XLogRecPtr *stoppos,
! 				  int fsync_interval, bool reply_fsync);
  static int CopyStreamPoll(PGconn *conn, long timeout_ms);
  static int CopyStreamReceive(PGconn *conn, long timeout, char **buffer);
  static bool ProcessKeepaliveMsg(PGconn *conn, char *copybuf, int len,
! 								XLogRecPtr blockpos);
  static bool ProcessXLogDataMsg(PGconn *conn, char *copybuf, int len,
  							   XLogRecPtr *blockpos, uint32 timeline,
  							   char *basedir, stream_stop_callback stream_stop,
! 							   char *partial_suffix, bool reply_fsync);
  static PGresult *HandleEndOfCopyStream(PGconn *conn, char *copybuf,
  									   XLogRecPtr blockpos, char *basedir, char *partial_suffix,
! 									   XLogRecPtr *stoppos, bool reply_fsync);
  static bool CheckCopyStreamStop(PGconn *conn, XLogRecPtr blockpos,
  								uint32 timeline, char *basedir,
  								stream_stop_callback stream_stop,
! 								char *partial_suffix, XLogRecPtr *stoppos,
! 								bool reply_fsync);
  static long CalculateCopyStreamSleeptime(int64 now, int standby_message_timeout,
! 										 int fsync_interval,
  										 XLogRecPtr blockpos);
  
  static bool ReadEndOfStreamingResult(PGresult *res, XLogRecPtr *startpos,
  						 uint32 *timeline);
+ static bool sendFeedback(PGconn *conn, XLogRecPtr blockpos, int64 now,
+ 						 bool replyRequested);
  
  /*
   * Open a new WAL file in the specified directory.
***************
*** 154,160 **** open_walfile(XLogRecPtr startpoint, uint32 timeline, char *basedir,
   * and returns false, otherwise returns true.
   */
  static bool
! close_walfile(char *basedir, char *partial_suffix, XLogRecPtr pos)
  {
  	off_t		currpos;
  
--- 158,164 ----
   * and returns false, otherwise returns true.
   */
  static bool
! close_walfile(char *basedir, char *partial_suffix, XLogRecPtr pos, bool reply_fsync)
  {
  	off_t		currpos;
  
***************
*** 210,215 **** close_walfile(char *basedir, char *partial_suffix, XLogRecPtr pos)
--- 214,226 ----
  
  	lastFlushPosition = pos;
  	last_fsync = feGetCurrentTimestamp();
+ 	/* Send feedback! */
+ 	if (reply_fsync)
+ 	{
+ 		if (!sendFeedback(conn, pos, last_fsync, false))
+ 			return false;
+ 		last_status = last_fsync;
+ 	}
  	return true;
  }
  
***************
*** 443,448 **** CheckServerVersionForStreaming(PGconn *conn)
--- 454,462 ----
   * fsync_interval controls how often we flush to the received WAL file,
   * in milliseconds.
   *
+  * If 'reply_fsync' is true, status packets sent to server as soon as
+  * after fsync.
+  *
   * Note: The log position *must* be at a log segment start!
   */
  bool
***************
*** 450,456 **** ReceiveXlogStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				  char *sysidentifier, char *basedir,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout, char *partial_suffix,
! 				  int fsync_interval)
  {
  	char		query[128];
  	char		slotcmd[128];
--- 464,470 ----
  				  char *sysidentifier, char *basedir,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout, char *partial_suffix,
! 				  int fsync_interval, bool reply_fsync)
  {
  	char		query[128];
  	char		slotcmd[128];
***************
*** 595,601 **** ReceiveXlogStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  		/* Stream the WAL */
  		res = HandleCopyStream(conn, startpos, timeline, basedir, stream_stop,
  							   standby_message_timeout, partial_suffix,
! 							   &stoppos, fsync_interval);
  		if (res == NULL)
  			goto error;
  
--- 609,615 ----
  		/* Stream the WAL */
  		res = HandleCopyStream(conn, startpos, timeline, basedir, stream_stop,
  							   standby_message_timeout, partial_suffix,
! 							   &stoppos, fsync_interval, reply_fsync);
  		if (res == NULL)
  			goto error;
  
***************
*** 760,769 **** static PGresult *
  HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				 char *basedir, stream_stop_callback stream_stop,
  				 int standby_message_timeout, char *partial_suffix,
! 				 XLogRecPtr *stoppos, int fsync_interval)
  {
  	char	   *copybuf = NULL;
- 	int64		last_status = -1;
  	XLogRecPtr	blockpos = startpos;
  
  	still_sending = true;
--- 774,782 ----
  HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				 char *basedir, stream_stop_callback stream_stop,
  				 int standby_message_timeout, char *partial_suffix,
! 				 XLogRecPtr *stoppos, int fsync_interval, bool reply_fsync)
  {
  	char	   *copybuf = NULL;
  	XLogRecPtr	blockpos = startpos;
  
  	still_sending = true;
***************
*** 778,784 **** HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  		 * Check if we should continue streaming, or abort at this point.
  		 */
  		if (!CheckCopyStreamStop(conn, blockpos, timeline, basedir,
! 								stream_stop, partial_suffix, stoppos))
  			goto error;
  
  		now = feGetCurrentTimestamp();
--- 791,797 ----
  		 * Check if we should continue streaming, or abort at this point.
  		 */
  		if (!CheckCopyStreamStop(conn, blockpos, timeline, basedir,
! 								stream_stop, partial_suffix, stoppos, reply_fsync))
  			goto error;
  
  		now = feGetCurrentTimestamp();
***************
*** 802,807 **** HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
--- 815,827 ----
  
  			lastFlushPosition = blockpos;
  			last_fsync = now;
+ 			/* Send feedback! */
+ 			if (reply_fsync)
+ 			{
+ 				if (!sendFeedback(conn, blockpos, now, false))
+ 					goto error;
+ 				last_status = now;
+ 			}
  		}
  
  		/*
***************
*** 821,827 **** HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  		 * Calculate how long send/receive loops should sleep
  		 */
  		sleeptime = CalculateCopyStreamSleeptime(now, standby_message_timeout,
! 												 last_status, fsync_interval, blockpos);
  
  		r = CopyStreamReceive(conn, sleeptime, &copybuf);
  		while (r != 0)
--- 841,847 ----
  		 * Calculate how long send/receive loops should sleep
  		 */
  		sleeptime = CalculateCopyStreamSleeptime(now, standby_message_timeout,
! 												 fsync_interval, blockpos);
  
  		r = CopyStreamReceive(conn, sleeptime, &copybuf);
  		while (r != 0)
***************
*** 831,837 **** HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  			if (r == -2)
  			{
  				PGresult	*res = HandleEndOfCopyStream(conn, copybuf, blockpos,
! 														 basedir, partial_suffix, stoppos);
  				if (res == NULL)
  					goto error;
  				else
--- 851,857 ----
  			if (r == -2)
  			{
  				PGresult	*res = HandleEndOfCopyStream(conn, copybuf, blockpos,
! 														 basedir, partial_suffix, stoppos, reply_fsync);
  				if (res == NULL)
  					goto error;
  				else
***************
*** 841,861 **** HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  			/* Check the message type. */
  			if (copybuf[0] == 'k')
  			{
! 				if (!ProcessKeepaliveMsg(conn, copybuf, r, blockpos,
! 										 &last_status))
  					goto error;
  			}
  			else if (copybuf[0] == 'w')
  			{
  				if (!ProcessXLogDataMsg(conn, copybuf, r, &blockpos,
! 										timeline, basedir, stream_stop, partial_suffix))
  					goto error;
  
  				/*
  				 * Check if we should continue streaming, or abort at this point.
  				 */
  				if (!CheckCopyStreamStop(conn, blockpos, timeline, basedir,
! 										 stream_stop, partial_suffix, stoppos))
  					goto error;
  			}
  			else
--- 861,880 ----
  			/* Check the message type. */
  			if (copybuf[0] == 'k')
  			{
! 				if (!ProcessKeepaliveMsg(conn, copybuf, r, blockpos))
  					goto error;
  			}
  			else if (copybuf[0] == 'w')
  			{
  				if (!ProcessXLogDataMsg(conn, copybuf, r, &blockpos,
! 										timeline, basedir, stream_stop, partial_suffix, reply_fsync))
  					goto error;
  
  				/*
  				 * Check if we should continue streaming, or abort at this point.
  				 */
  				if (!CheckCopyStreamStop(conn, blockpos, timeline, basedir,
! 										 stream_stop, partial_suffix, stoppos, reply_fsync))
  					goto error;
  			}
  			else
***************
*** 995,1001 **** CopyStreamReceive(PGconn *conn, long timeout, char **buffer)
   */
  static bool
  ProcessKeepaliveMsg(PGconn *conn, char *copybuf, int len,
! 					XLogRecPtr blockpos, int64 *last_status)
  {
  	int			pos;
  	bool		replyRequested;
--- 1014,1020 ----
   */
  static bool
  ProcessKeepaliveMsg(PGconn *conn, char *copybuf, int len,
! 					XLogRecPtr blockpos)
  {
  	int			pos;
  	bool		replyRequested;
***************
*** 1024,1030 **** ProcessKeepaliveMsg(PGconn *conn, char *copybuf, int len,
  		now = feGetCurrentTimestamp();
  		if (!sendFeedback(conn, blockpos, now, false))
  			return false;
! 		*last_status = now;
  	}
  
  	return true;
--- 1043,1049 ----
  		now = feGetCurrentTimestamp();
  		if (!sendFeedback(conn, blockpos, now, false))
  			return false;
! 		last_status = now;
  	}
  
  	return true;
***************
*** 1037,1043 **** static bool
  ProcessXLogDataMsg(PGconn *conn, char *copybuf, int len,
  				   XLogRecPtr *blockpos, uint32 timeline,
  				   char *basedir, stream_stop_callback stream_stop,
! 				   char *partial_suffix)
  {
  	int			xlogoff;
  	int			bytes_left;
--- 1056,1062 ----
  ProcessXLogDataMsg(PGconn *conn, char *copybuf, int len,
  				   XLogRecPtr *blockpos, uint32 timeline,
  				   char *basedir, stream_stop_callback stream_stop,
! 				   char *partial_suffix, bool reply_fsync)
  {
  	int			xlogoff;
  	int			bytes_left;
***************
*** 1145,1151 **** ProcessXLogDataMsg(PGconn *conn, char *copybuf, int len,
  		/* Did we reach the end of a WAL segment? */
  		if (*blockpos % XLOG_SEG_SIZE == 0)
  		{
! 			if (!close_walfile(basedir, partial_suffix, *blockpos))
  				/* Error message written in close_walfile() */
  				return false;
  
--- 1164,1170 ----
  		/* Did we reach the end of a WAL segment? */
  		if (*blockpos % XLOG_SEG_SIZE == 0)
  		{
! 			if (!close_walfile(basedir, partial_suffix, *blockpos, reply_fsync))
  				/* Error message written in close_walfile() */
  				return false;
  
***************
*** 1175,1181 **** ProcessXLogDataMsg(PGconn *conn, char *copybuf, int len,
  static PGresult *
  HandleEndOfCopyStream(PGconn *conn, char *copybuf,
  					  XLogRecPtr blockpos, char *basedir, char *partial_suffix,
! 					  XLogRecPtr *stoppos)
  {
  	PGresult   *res = PQgetResult(conn);
  
--- 1194,1200 ----
  static PGresult *
  HandleEndOfCopyStream(PGconn *conn, char *copybuf,
  					  XLogRecPtr blockpos, char *basedir, char *partial_suffix,
! 					  XLogRecPtr *stoppos, bool reply_fsync)
  {
  	PGresult   *res = PQgetResult(conn);
  
***************
*** 1186,1192 **** HandleEndOfCopyStream(PGconn *conn, char *copybuf,
  	 */
  	if (still_sending)
  	{
! 		if (!close_walfile(basedir, partial_suffix, blockpos))
  		{
  			/* Error message written in close_walfile() */
  			PQclear(res);
--- 1205,1211 ----
  	 */
  	if (still_sending)
  	{
! 		if (!close_walfile(basedir, partial_suffix, blockpos, reply_fsync))
  		{
  			/* Error message written in close_walfile() */
  			PQclear(res);
***************
*** 1218,1228 **** HandleEndOfCopyStream(PGconn *conn, char *copybuf,
  static bool
  CheckCopyStreamStop(PGconn *conn, XLogRecPtr blockpos, uint32 timeline,
  					char *basedir, stream_stop_callback stream_stop,
! 					char *partial_suffix, XLogRecPtr *stoppos)
  {
  	if (still_sending && stream_stop(blockpos, timeline, false))
  	{
! 		if (!close_walfile(basedir, partial_suffix, blockpos))
  		{
  			/* Potential error message is written by close_walfile */
  			return false;
--- 1237,1248 ----
  static bool
  CheckCopyStreamStop(PGconn *conn, XLogRecPtr blockpos, uint32 timeline,
  					char *basedir, stream_stop_callback stream_stop,
! 					char *partial_suffix, XLogRecPtr *stoppos,
! 					bool reply_fsync)
  {
  	if (still_sending && stream_stop(blockpos, timeline, false))
  	{
! 		if (!close_walfile(basedir, partial_suffix, blockpos, reply_fsync))
  		{
  			/* Potential error message is written by close_walfile */
  			return false;
***************
*** 1244,1250 **** CheckCopyStreamStop(PGconn *conn, XLogRecPtr blockpos, uint32 timeline,
   */
  static long
  CalculateCopyStreamSleeptime(int64 now, int standby_message_timeout,
! 							 int64 last_status, int fsync_interval, XLogRecPtr blockpos)
  {
  	int64		targettime = 0;
  	int64		status_targettime = 0;
--- 1264,1270 ----
   */
  static long
  CalculateCopyStreamSleeptime(int64 now, int standby_message_timeout,
! 							 int fsync_interval, XLogRecPtr blockpos)
  {
  	int64		targettime = 0;
  	int64		status_targettime = 0;
*** a/src/bin/pg_basebackup/receivelog.h
--- b/src/bin/pg_basebackup/receivelog.h
***************
*** 17,20 **** extern bool ReceiveXlogStream(PGconn *conn,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout,
  				  char *partial_suffix,
! 				  int fsync_interval);
--- 17,21 ----
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout,
  				  char *partial_suffix,
! 				  int fsync_interval,
! 				  bool reply_fsync);

*** a/doc/src/sgml/ref/pg_receivexlog.sgml
--- b/doc/src/sgml/ref/pg_receivexlog.sgml
***************
*** 196,201 **** PostgreSQL documentation
--- 196,211 ----
       </varlistentry>
  
       <varlistentry>
+       <term><option>-r</></term>
+       <term><option>--reply-fsync</></term>
+       <listitem>
+        <para>
+         status packets sent to server as soon as after fsync.
+        </para>
+       </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
        <term><option>-U <replaceable>username</replaceable></option></term>
        <term><option>--username=<replaceable class="parameter">username</replaceable></option></term>
        <listitem>
*** a/src/bin/pg_basebackup/pg_basebackup.c
--- b/src/bin/pg_basebackup/pg_basebackup.c
***************
*** 371,377 **** LogStreamerMain(logstreamer_param *param)
  	if (!ReceiveXlogStream(param->bgconn, param->startptr, param->timeline,
  						   param->sysidentifier, param->xlogdir,
  						   reached_end_position, standby_message_timeout,
! 						   NULL, 0))
  
  		/*
  		 * Any errors will already have been reported in the function process,
--- 371,377 ----
  	if (!ReceiveXlogStream(param->bgconn, param->startptr, param->timeline,
  						   param->sysidentifier, param->xlogdir,
  						   reached_end_position, standby_message_timeout,
! 						   NULL, 0, false))
  
  		/*
  		 * Any errors will already have been reported in the function process,
*** a/src/bin/pg_basebackup/pg_receivexlog.c
--- b/src/bin/pg_basebackup/pg_receivexlog.c
***************
*** 38,44 **** static int	noloop = 0;
  static int	standby_message_timeout = 10 * 1000;		/* 10 sec = default */
  static int	fsync_interval = 0; /* 0 = default */
  static volatile bool time_to_abort = false;
! 
  
  static void usage(void);
  static XLogRecPtr FindStreamingStart(uint32 *tli);
--- 38,44 ----
  static int	standby_message_timeout = 10 * 1000;		/* 10 sec = default */
  static int	fsync_interval = 0; /* 0 = default */
  static volatile bool time_to_abort = false;
! static bool	reply_fsync = false;
  
  static void usage(void);
  static XLogRecPtr FindStreamingStart(uint32 *tli);
***************
*** 74,79 **** usage(void)
--- 74,80 ----
  	printf(_("  -p, --port=PORT        database server port number\n"));
  	printf(_("  -s, --status-interval=INTERVAL\n"
  			 "                         time between status packets sent to server (in seconds)\n"));
+ 	printf(_("  -r, --reply-fsync      status packets sent to server as soon as after fsync\n"));
  	printf(_("  -U, --username=NAME    connect as specified database user\n"));
  	printf(_("  -w, --no-password      never prompt for password\n"));
  	printf(_("  -W, --password         force password prompt (should happen automatically)\n"));
***************
*** 334,340 **** StreamLog(void)
  
  	ReceiveXlogStream(conn, startpos, starttli, NULL, basedir,
  					  stop_streaming, standby_message_timeout, ".partial",
! 					  fsync_interval);
  
  	PQfinish(conn);
  }
--- 335,341 ----
  
  	ReceiveXlogStream(conn, startpos, starttli, NULL, basedir,
  					  stop_streaming, standby_message_timeout, ".partial",
! 					  fsync_interval, reply_fsync);
  
  	PQfinish(conn);
  }
***************
*** 368,373 **** main(int argc, char **argv)
--- 369,375 ----
  		{"no-password", no_argument, NULL, 'w'},
  		{"password", no_argument, NULL, 'W'},
  		{"status-interval", required_argument, NULL, 's'},
+ 		{"reply-fsync", no_argument, NULL, 'r'},
  		{"slot", required_argument, NULL, 'S'},
  		{"verbose", no_argument, NULL, 'v'},
  		{NULL, 0, NULL, 0}
***************
*** 394,400 **** main(int argc, char **argv)
  		}
  	}
  
! 	while ((c = getopt_long(argc, argv, "D:d:h:p:U:s:S:nF:wWv",
  							long_options, &option_index)) != -1)
  	{
  		switch (c)
--- 396,402 ----
  		}
  	}
  
! 	while ((c = getopt_long(argc, argv, "D:d:h:p:U:s:rS:nF:wWv",
  							long_options, &option_index)) != -1)
  	{
  		switch (c)
***************
*** 435,440 **** main(int argc, char **argv)
--- 437,445 ----
  					exit(1);
  				}
  				break;
+ 			case 'r':
+ 				reply_fsync = true;
+ 				break;
  			case 'S':
  				replication_slot = pg_strdup(optarg);
  				break;
*** a/src/bin/pg_basebackup/receivelog.c
--- b/src/bin/pg_basebackup/receivelog.c
***************
*** 38,44 **** static PGresult *HandleCopyStream(PGconn *conn, XLogRecPtr startpos,
  				 uint32 timeline, char *basedir,
  			   stream_stop_callback stream_stop, int standby_message_timeout,
  				  char *partial_suffix, XLogRecPtr *stoppos,
! 				  int fsync_interval);
  static int CopyStreamPoll(PGconn *conn, long timeout_ms);
  static int CopyStreamReceive(PGconn *conn, long timeout, char **buffer);
  static bool ProcessKeepaliveMsg(PGconn *conn, char *copybuf, int len,
--- 38,44 ----
  				 uint32 timeline, char *basedir,
  			   stream_stop_callback stream_stop, int standby_message_timeout,
  				  char *partial_suffix, XLogRecPtr *stoppos,
! 				  int fsync_interval, bool reply_fsync);
  static int CopyStreamPoll(PGconn *conn, long timeout_ms);
  static int CopyStreamReceive(PGconn *conn, long timeout, char **buffer);
  static bool ProcessKeepaliveMsg(PGconn *conn, char *copybuf, int len,
***************
*** 443,448 **** CheckServerVersionForStreaming(PGconn *conn)
--- 443,451 ----
   * fsync_interval controls how often we flush to the received WAL file,
   * in milliseconds.
   *
+  * If 'reply_fsync' is true, status packets sent to server as soon as
+  * after fsync.
+  *
   * Note: The log position *must* be at a log segment start!
   */
  bool
***************
*** 450,456 **** ReceiveXlogStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				  char *sysidentifier, char *basedir,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout, char *partial_suffix,
! 				  int fsync_interval)
  {
  	char		query[128];
  	char		slotcmd[128];
--- 453,459 ----
  				  char *sysidentifier, char *basedir,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout, char *partial_suffix,
! 				  int fsync_interval, bool reply_fsync)
  {
  	char		query[128];
  	char		slotcmd[128];
***************
*** 595,601 **** ReceiveXlogStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  		/* Stream the WAL */
  		res = HandleCopyStream(conn, startpos, timeline, basedir, stream_stop,
  							   standby_message_timeout, partial_suffix,
! 							   &stoppos, fsync_interval);
  		if (res == NULL)
  			goto error;
  
--- 598,604 ----
  		/* Stream the WAL */
  		res = HandleCopyStream(conn, startpos, timeline, basedir, stream_stop,
  							   standby_message_timeout, partial_suffix,
! 							   &stoppos, fsync_interval, reply_fsync);
  		if (res == NULL)
  			goto error;
  
***************
*** 760,770 **** static PGresult *
  HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				 char *basedir, stream_stop_callback stream_stop,
  				 int standby_message_timeout, char *partial_suffix,
! 				 XLogRecPtr *stoppos, int fsync_interval)
  {
  	char	   *copybuf = NULL;
  	int64		last_status = -1;
  	XLogRecPtr	blockpos = startpos;
  
  	still_sending = true;
  
--- 763,774 ----
  HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				 char *basedir, stream_stop_callback stream_stop,
  				 int standby_message_timeout, char *partial_suffix,
! 				 XLogRecPtr *stoppos, int fsync_interval, bool reply_fsync)
  {
  	char	   *copybuf = NULL;
  	int64		last_status = -1;
  	XLogRecPtr	blockpos = startpos;
+ 	XLogRecPtr	lastFeedbackFlushPosition = startpos;
  
  	still_sending = true;
  
***************
*** 807,820 **** HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  		/*
  		 * Potentially send a status message to the master
  		 */
! 		if (still_sending && standby_message_timeout > 0 &&
! 			feTimestampDifferenceExceeds(last_status, now,
! 										 standby_message_timeout))
  		{
  			/* Time to send feedback! */
  			if (!sendFeedback(conn, blockpos, now, false))
  				goto error;
  			last_status = now;
  		}
  
  		/*
--- 811,826 ----
  		/*
  		 * Potentially send a status message to the master
  		 */
! 		if ((still_sending && standby_message_timeout > 0 &&
! 			feTimestampDifferenceExceeds(last_status, now, standby_message_timeout)) ||
! 			(reply_fsync && lastFeedbackFlushPosition != lastFlushPosition))
  		{
  			/* Time to send feedback! */
  			if (!sendFeedback(conn, blockpos, now, false))
  				goto error;
  			last_status = now;
+ 			if (reply_fsync)
+ 				lastFeedbackFlushPosition = lastFlushPosition;
  		}
  
  		/*
*** a/src/bin/pg_basebackup/receivelog.h
--- b/src/bin/pg_basebackup/receivelog.h
***************
*** 17,20 **** extern bool ReceiveXlogStream(PGconn *conn,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout,
  				  char *partial_suffix,
! 				  int fsync_interval);
--- 17,21 ----
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout,
  				  char *partial_suffix,
! 				  int fsync_interval,
! 				  bool reply_fsync);

*** a/doc/src/sgml/ref/pg_receivexlog.sgml
--- b/doc/src/sgml/ref/pg_receivexlog.sgml
***************
*** 196,201 **** PostgreSQL documentation
--- 196,212 ----
       </varlistentry>
  
       <varlistentry>
+       <term><option>-r</></term>
+       <term><option>--reply-fsync</></term>
+       <listitem>
+        <para>
+         status packets sent to server as soon as after fsync.
+         If you want to report the flush position to the server, should use -S option.
+        </para>
+       </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
        <term><option>-U <replaceable>username</replaceable></option></term>
        <term><option>--username=<replaceable class="parameter">username</replaceable></option></term>
        <listitem>
*** a/src/bin/pg_basebackup/pg_basebackup.c
--- b/src/bin/pg_basebackup/pg_basebackup.c
***************
*** 371,377 **** LogStreamerMain(logstreamer_param *param)
  	if (!ReceiveXlogStream(param->bgconn, param->startptr, param->timeline,
  						   param->sysidentifier, param->xlogdir,
  						   reached_end_position, standby_message_timeout,
! 						   NULL, 0))
  
  		/*
  		 * Any errors will already have been reported in the function process,
--- 371,377 ----
  	if (!ReceiveXlogStream(param->bgconn, param->startptr, param->timeline,
  						   param->sysidentifier, param->xlogdir,
  						   reached_end_position, standby_message_timeout,
! 						   NULL, 0, false))
  
  		/*
  		 * Any errors will already have been reported in the function process,
*** a/src/bin/pg_basebackup/pg_receivexlog.c
--- b/src/bin/pg_basebackup/pg_receivexlog.c
***************
*** 38,44 **** static int	noloop = 0;
  static int	standby_message_timeout = 10 * 1000;		/* 10 sec = default */
  static int	fsync_interval = 0; /* 0 = default */
  static volatile bool time_to_abort = false;
! 
  
  static void usage(void);
  static XLogRecPtr FindStreamingStart(uint32 *tli);
--- 38,44 ----
  static int	standby_message_timeout = 10 * 1000;		/* 10 sec = default */
  static int	fsync_interval = 0; /* 0 = default */
  static volatile bool time_to_abort = false;
! static bool	reply_fsync = false;
  
  static void usage(void);
  static XLogRecPtr FindStreamingStart(uint32 *tli);
***************
*** 74,79 **** usage(void)
--- 74,81 ----
  	printf(_("  -p, --port=PORT        database server port number\n"));
  	printf(_("  -s, --status-interval=INTERVAL\n"
  			 "                         time between status packets sent to server (in seconds)\n"));
+ 	printf(_("  -r, --reply-fsync      status packets sent to server as soon as after fsync\n"
+ 			 "                         If you want to report the flush position to the server, should use -S option.\n"));
  	printf(_("  -U, --username=NAME    connect as specified database user\n"));
  	printf(_("  -w, --no-password      never prompt for password\n"));
  	printf(_("  -W, --password         force password prompt (should happen automatically)\n"));
***************
*** 334,340 **** StreamLog(void)
  
  	ReceiveXlogStream(conn, startpos, starttli, NULL, basedir,
  					  stop_streaming, standby_message_timeout, ".partial",
! 					  fsync_interval);
  
  	PQfinish(conn);
  }
--- 336,342 ----
  
  	ReceiveXlogStream(conn, startpos, starttli, NULL, basedir,
  					  stop_streaming, standby_message_timeout, ".partial",
! 					  fsync_interval, reply_fsync);
  
  	PQfinish(conn);
  }
***************
*** 368,373 **** main(int argc, char **argv)
--- 370,376 ----
  		{"no-password", no_argument, NULL, 'w'},
  		{"password", no_argument, NULL, 'W'},
  		{"status-interval", required_argument, NULL, 's'},
+ 		{"reply-fsync", no_argument, NULL, 'r'},
  		{"slot", required_argument, NULL, 'S'},
  		{"verbose", no_argument, NULL, 'v'},
  		{NULL, 0, NULL, 0}
***************
*** 394,400 **** main(int argc, char **argv)
  		}
  	}
  
! 	while ((c = getopt_long(argc, argv, "D:d:h:p:U:s:S:nF:wWv",
  							long_options, &option_index)) != -1)
  	{
  		switch (c)
--- 397,403 ----
  		}
  	}
  
! 	while ((c = getopt_long(argc, argv, "D:d:h:p:U:s:rS:nF:wWv",
  							long_options, &option_index)) != -1)
  	{
  		switch (c)
***************
*** 435,440 **** main(int argc, char **argv)
--- 438,446 ----
  					exit(1);
  				}
  				break;
+ 			case 'r':
+ 				reply_fsync = true;
+ 				break;
  			case 'S':
  				replication_slot = pg_strdup(optarg);
  				break;
*** a/src/bin/pg_basebackup/receivelog.c
--- b/src/bin/pg_basebackup/receivelog.c
***************
*** 38,44 **** static PGresult *HandleCopyStream(PGconn *conn, XLogRecPtr startpos,
  				 uint32 timeline, char *basedir,
  			   stream_stop_callback stream_stop, int standby_message_timeout,
  				  char *partial_suffix, XLogRecPtr *stoppos,
! 				  int fsync_interval);
  static int CopyStreamPoll(PGconn *conn, long timeout_ms);
  static int CopyStreamReceive(PGconn *conn, long timeout, char **buffer);
  static bool ProcessKeepaliveMsg(PGconn *conn, char *copybuf, int len,
--- 38,44 ----
  				 uint32 timeline, char *basedir,
  			   stream_stop_callback stream_stop, int standby_message_timeout,
  				  char *partial_suffix, XLogRecPtr *stoppos,
! 				  int fsync_interval, bool reply_fsync);
  static int CopyStreamPoll(PGconn *conn, long timeout_ms);
  static int CopyStreamReceive(PGconn *conn, long timeout, char **buffer);
  static bool ProcessKeepaliveMsg(PGconn *conn, char *copybuf, int len,
***************
*** 443,448 **** CheckServerVersionForStreaming(PGconn *conn)
--- 443,451 ----
   * fsync_interval controls how often we flush to the received WAL file,
   * in milliseconds.
   *
+  * If 'reply_fsync' is true, status packets sent to server as soon as
+  * after fsync.
+  *
   * Note: The log position *must* be at a log segment start!
   */
  bool
***************
*** 450,456 **** ReceiveXlogStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				  char *sysidentifier, char *basedir,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout, char *partial_suffix,
! 				  int fsync_interval)
  {
  	char		query[128];
  	char		slotcmd[128];
--- 453,459 ----
  				  char *sysidentifier, char *basedir,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout, char *partial_suffix,
! 				  int fsync_interval, bool reply_fsync)
  {
  	char		query[128];
  	char		slotcmd[128];
***************
*** 595,601 **** ReceiveXlogStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  		/* Stream the WAL */
  		res = HandleCopyStream(conn, startpos, timeline, basedir, stream_stop,
  							   standby_message_timeout, partial_suffix,
! 							   &stoppos, fsync_interval);
  		if (res == NULL)
  			goto error;
  
--- 598,604 ----
  		/* Stream the WAL */
  		res = HandleCopyStream(conn, startpos, timeline, basedir, stream_stop,
  							   standby_message_timeout, partial_suffix,
! 							   &stoppos, fsync_interval, reply_fsync);
  		if (res == NULL)
  			goto error;
  
***************
*** 760,770 **** static PGresult *
  HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				 char *basedir, stream_stop_callback stream_stop,
  				 int standby_message_timeout, char *partial_suffix,
! 				 XLogRecPtr *stoppos, int fsync_interval)
  {
  	char	   *copybuf = NULL;
  	int64		last_status = -1;
  	XLogRecPtr	blockpos = startpos;
  
  	still_sending = true;
  
--- 763,774 ----
  HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				 char *basedir, stream_stop_callback stream_stop,
  				 int standby_message_timeout, char *partial_suffix,
! 				 XLogRecPtr *stoppos, int fsync_interval, bool reply_fsync)
  {
  	char	   *copybuf = NULL;
  	int64		last_status = -1;
  	XLogRecPtr	blockpos = startpos;
+ 	XLogRecPtr	lastFeedbackFlushPosition = startpos;
  
  	still_sending = true;
  
***************
*** 807,820 **** HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  		/*
  		 * Potentially send a status message to the master
  		 */
! 		if (still_sending && standby_message_timeout > 0 &&
! 			feTimestampDifferenceExceeds(last_status, now,
! 										 standby_message_timeout))
  		{
  			/* Time to send feedback! */
  			if (!sendFeedback(conn, blockpos, now, false))
  				goto error;
  			last_status = now;
  		}
  
  		/*
--- 811,826 ----
  		/*
  		 * Potentially send a status message to the master
  		 */
! 		if ((still_sending && standby_message_timeout > 0 &&
! 			feTimestampDifferenceExceeds(last_status, now, standby_message_timeout)) ||
! 			(reply_fsync && lastFeedbackFlushPosition != lastFlushPosition))
  		{
  			/* Time to send feedback! */
  			if (!sendFeedback(conn, blockpos, now, false))
  				goto error;
  			last_status = now;
+ 			if (reply_fsync)
+ 				lastFeedbackFlushPosition = lastFlushPosition;
  		}
  
  		/*
*** a/src/bin/pg_basebackup/receivelog.h
--- b/src/bin/pg_basebackup/receivelog.h
***************
*** 17,20 **** extern bool ReceiveXlogStream(PGconn *conn,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout,
  				  char *partial_suffix,
! 				  int fsync_interval);
--- 17,21 ----
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout,
  				  char *partial_suffix,
! 				  int fsync_interval,
! 				  bool reply_fsync);

*** a/doc/src/sgml/ref/pg_receivexlog.sgml
--- b/doc/src/sgml/ref/pg_receivexlog.sgml
***************
*** 196,201 **** PostgreSQL documentation
--- 196,212 ----
       </varlistentry>
  
       <varlistentry>
+       <term><option>-r</></term>
+       <term><option>--reply-fsync</></term>
+       <listitem>
+        <para>
+         status packets sent to server as soon as after fsync.
+         If you want to report the flush position to the server, should use -S option.
+        </para>
+       </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
        <term><option>-U <replaceable>username</replaceable></option></term>
        <term><option>--username=<replaceable class="parameter">username</replaceable></option></term>
        <listitem>
*** a/src/bin/pg_basebackup/pg_basebackup.c
--- b/src/bin/pg_basebackup/pg_basebackup.c
***************
*** 370,376 **** LogStreamerMain(logstreamer_param *param)
  	if (!ReceiveXlogStream(param->bgconn, param->startptr, param->timeline,
  						   param->sysidentifier, param->xlogdir,
  						   reached_end_position, standby_message_timeout,
! 						   NULL, 0))
  
  		/*
  		 * Any errors will already have been reported in the function process,
--- 370,376 ----
  	if (!ReceiveXlogStream(param->bgconn, param->startptr, param->timeline,
  						   param->sysidentifier, param->xlogdir,
  						   reached_end_position, standby_message_timeout,
! 						   NULL, 0, false))
  
  		/*
  		 * Any errors will already have been reported in the function process,
*** a/src/bin/pg_basebackup/pg_receivexlog.c
--- b/src/bin/pg_basebackup/pg_receivexlog.c
***************
*** 38,44 **** static int	noloop = 0;
  static int	standby_message_timeout = 10 * 1000;		/* 10 sec = default */
  static int	fsync_interval = 0; /* 0 = default */
  static volatile bool time_to_abort = false;
! 
  
  static void usage(void);
  static XLogRecPtr FindStreamingStart(uint32 *tli);
--- 38,44 ----
  static int	standby_message_timeout = 10 * 1000;		/* 10 sec = default */
  static int	fsync_interval = 0; /* 0 = default */
  static volatile bool time_to_abort = false;
! static bool	reply_fsync = false;
  
  static void usage(void);
  static XLogRecPtr FindStreamingStart(uint32 *tli);
***************
*** 74,79 **** usage(void)
--- 74,81 ----
  	printf(_("  -p, --port=PORT        database server port number\n"));
  	printf(_("  -s, --status-interval=INTERVAL\n"
  			 "                         time between status packets sent to server (in seconds)\n"));
+ 	printf(_("  -r, --reply-fsync      status packets sent to server as soon as after fsync\n"
+ 			 "                         If you want to report the flush position to the server, should use -S option.\n"));
  	printf(_("  -U, --username=NAME    connect as specified database user\n"));
  	printf(_("  -w, --no-password      never prompt for password\n"));
  	printf(_("  -W, --password         force password prompt (should happen automatically)\n"));
***************
*** 334,340 **** StreamLog(void)
  
  	ReceiveXlogStream(conn, startpos, starttli, NULL, basedir,
  					  stop_streaming, standby_message_timeout, ".partial",
! 					  fsync_interval);
  
  	PQfinish(conn);
  }
--- 336,342 ----
  
  	ReceiveXlogStream(conn, startpos, starttli, NULL, basedir,
  					  stop_streaming, standby_message_timeout, ".partial",
! 					  fsync_interval, reply_fsync);
  
  	PQfinish(conn);
  }
***************
*** 368,373 **** main(int argc, char **argv)
--- 370,376 ----
  		{"no-password", no_argument, NULL, 'w'},
  		{"password", no_argument, NULL, 'W'},
  		{"status-interval", required_argument, NULL, 's'},
+ 		{"reply-fsync", no_argument, NULL, 'r'},
  		{"slot", required_argument, NULL, 'S'},
  		{"verbose", no_argument, NULL, 'v'},
  		{NULL, 0, NULL, 0}
***************
*** 394,400 **** main(int argc, char **argv)
  		}
  	}
  
! 	while ((c = getopt_long(argc, argv, "D:d:h:p:U:s:S:nF:wWv",
  							long_options, &option_index)) != -1)
  	{
  		switch (c)
--- 397,403 ----
  		}
  	}
  
! 	while ((c = getopt_long(argc, argv, "D:d:h:p:U:s:rS:nF:wWv",
  							long_options, &option_index)) != -1)
  	{
  		switch (c)
***************
*** 435,440 **** main(int argc, char **argv)
--- 438,446 ----
  					exit(1);
  				}
  				break;
+ 			case 'r':
+ 				reply_fsync = true;
+ 				break;
  			case 'S':
  				replication_slot = pg_strdup(optarg);
  				break;
*** a/src/bin/pg_basebackup/receivelog.c
--- b/src/bin/pg_basebackup/receivelog.c
***************
*** 38,44 **** static PGresult *HandleCopyStream(PGconn *conn, XLogRecPtr startpos,
  				 uint32 timeline, char *basedir,
  			   stream_stop_callback stream_stop, int standby_message_timeout,
  				  char *partial_suffix, XLogRecPtr *stoppos,
! 				  int fsync_interval);
  static int CopyStreamPoll(PGconn *conn, long timeout_ms);
  static int CopyStreamReceive(PGconn *conn, long timeout, char **buffer);
  static bool ProcessKeepaliveMsg(PGconn *conn, char *copybuf, int len,
--- 38,44 ----
  				 uint32 timeline, char *basedir,
  			   stream_stop_callback stream_stop, int standby_message_timeout,
  				  char *partial_suffix, XLogRecPtr *stoppos,
! 				  int fsync_interval, bool reply_fsync);
  static int CopyStreamPoll(PGconn *conn, long timeout_ms);
  static int CopyStreamReceive(PGconn *conn, long timeout, char **buffer);
  static bool ProcessKeepaliveMsg(PGconn *conn, char *copybuf, int len,
***************
*** 443,448 **** CheckServerVersionForStreaming(PGconn *conn)
--- 443,451 ----
   * fsync_interval controls how often we flush to the received WAL file,
   * in milliseconds.
   *
+  * If 'reply_fsync' is true, status packets sent to server as soon as
+  * after fsync.
+  *
   * Note: The log position *must* be at a log segment start!
   */
  bool
***************
*** 450,456 **** ReceiveXlogStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				  char *sysidentifier, char *basedir,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout, char *partial_suffix,
! 				  int fsync_interval)
  {
  	char		query[128];
  	char		slotcmd[128];
--- 453,459 ----
  				  char *sysidentifier, char *basedir,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout, char *partial_suffix,
! 				  int fsync_interval, bool reply_fsync)
  {
  	char		query[128];
  	char		slotcmd[128];
***************
*** 595,601 **** ReceiveXlogStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  		/* Stream the WAL */
  		res = HandleCopyStream(conn, startpos, timeline, basedir, stream_stop,
  							   standby_message_timeout, partial_suffix,
! 							   &stoppos, fsync_interval);
  		if (res == NULL)
  			goto error;
  
--- 598,604 ----
  		/* Stream the WAL */
  		res = HandleCopyStream(conn, startpos, timeline, basedir, stream_stop,
  							   standby_message_timeout, partial_suffix,
! 							   &stoppos, fsync_interval, reply_fsync);
  		if (res == NULL)
  			goto error;
  
***************
*** 760,770 **** static PGresult *
  HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				 char *basedir, stream_stop_callback stream_stop,
  				 int standby_message_timeout, char *partial_suffix,
! 				 XLogRecPtr *stoppos, int fsync_interval)
  {
  	char	   *copybuf = NULL;
  	int64		last_status = -1;
  	XLogRecPtr	blockpos = startpos;
  
  	still_sending = true;
  
--- 763,774 ----
  HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				 char *basedir, stream_stop_callback stream_stop,
  				 int standby_message_timeout, char *partial_suffix,
! 				 XLogRecPtr *stoppos, int fsync_interval, bool reply_fsync)
  {
  	char	   *copybuf = NULL;
  	int64		last_status = -1;
  	XLogRecPtr	blockpos = startpos;
+ 	XLogRecPtr	lastFeedbackFlushPosition = startpos;
  
  	still_sending = true;
  
***************
*** 807,820 **** HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  		/*
  		 * Potentially send a status message to the master
  		 */
! 		if (still_sending && standby_message_timeout > 0 &&
! 			feTimestampDifferenceExceeds(last_status, now,
! 										 standby_message_timeout))
  		{
  			/* Time to send feedback! */
  			if (!sendFeedback(conn, blockpos, now, false))
  				goto error;
  			last_status = now;
  		}
  
  		/*
--- 811,826 ----
  		/*
  		 * Potentially send a status message to the master
  		 */
! 		if ((still_sending && standby_message_timeout > 0 &&
! 			feTimestampDifferenceExceeds(last_status, now, standby_message_timeout)) ||
! 			(reply_fsync && lastFeedbackFlushPosition != lastFlushPosition))
  		{
  			/* Time to send feedback! */
  			if (!sendFeedback(conn, blockpos, now, false))
  				goto error;
  			last_status = now;
+ 			if (reply_fsync)
+ 				lastFeedbackFlushPosition = lastFlushPosition;
  		}
  
  		/*
*** a/src/bin/pg_basebackup/receivelog.h
--- b/src/bin/pg_basebackup/receivelog.h
***************
*** 31,36 **** extern bool ReceiveXlogStream(PGconn *conn,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout,
  				  char *partial_suffix,
! 				  int fsync_interval);
  
  #endif	/* RECEIVELOG_H */
--- 31,37 ----
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout,
  				  char *partial_suffix,
! 				  int fsync_interval,
! 				  bool reply_fsync);
  
  #endif	/* RECEIVELOG_H */

*** a/doc/src/sgml/ref/pg_receivexlog.sgml
--- b/doc/src/sgml/ref/pg_receivexlog.sgml
***************
*** 196,201 **** PostgreSQL documentation
--- 196,212 ----
       </varlistentry>
  
       <varlistentry>
+       <term><option>-r</></term>
+       <term><option>--reply-fsync</></term>
+       <listitem>
+        <para>
+         status packets sent to server as soon as after fsync.
+         If you want to report the flush position to the server, should use -S option.
+        </para>
+       </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
        <term><option>-U <replaceable>username</replaceable></option></term>
        <term><option>--username=<replaceable class="parameter">username</replaceable></option></term>
        <listitem>
*** a/src/bin/pg_basebackup/pg_basebackup.c
--- b/src/bin/pg_basebackup/pg_basebackup.c
***************
*** 370,376 **** LogStreamerMain(logstreamer_param *param)
  	if (!ReceiveXlogStream(param->bgconn, param->startptr, param->timeline,
  						   param->sysidentifier, param->xlogdir,
  						   reached_end_position, standby_message_timeout,
! 						   NULL, 0))
  
  		/*
  		 * Any errors will already have been reported in the function process,
--- 370,376 ----
  	if (!ReceiveXlogStream(param->bgconn, param->startptr, param->timeline,
  						   param->sysidentifier, param->xlogdir,
  						   reached_end_position, standby_message_timeout,
! 						   NULL, 0, false))
  
  		/*
  		 * Any errors will already have been reported in the function process,
*** a/src/bin/pg_basebackup/pg_receivexlog.c
--- b/src/bin/pg_basebackup/pg_receivexlog.c
***************
*** 40,46 **** static int	fsync_interval = 0; /* 0 = default */
  static volatile bool time_to_abort = false;
  static bool do_create_slot = false;
  static bool do_drop_slot = false;
! 
  
  static void usage(void);
  static DIR* get_destination_dir(char *dest_folder);
--- 40,46 ----
  static volatile bool time_to_abort = false;
  static bool do_create_slot = false;
  static bool do_drop_slot = false;
! static bool	reply_fsync = false;
  
  static void usage(void);
  static DIR* get_destination_dir(char *dest_folder);
***************
*** 71,76 **** usage(void)
--- 71,78 ----
  	printf(_("  -n, --no-loop          do not loop on connection lost\n"));
  	printf(_("  -s, --status-interval=SECS\n"
  			 "                         time between status packets sent to server (default: %d)\n"), (standby_message_timeout / 1000));
+ 	printf(_("  -r, --reply-fsync      status packets sent to server as soon as after fsync\n"
+  			 "                         If you want to report the flush position to the server, should use -S option.\n"));
  	printf(_("  -S, --slot=SLOTNAME    replication slot to use\n"));
  	printf(_("  -v, --verbose          output verbose messages\n"));
  	printf(_("  -V, --version          output version information, then exit\n"));
***************
*** 342,348 **** StreamLog(void)
  
  	ReceiveXlogStream(conn, startpos, starttli, NULL, basedir,
  					  stop_streaming, standby_message_timeout, ".partial",
! 					  fsync_interval);
  
  	PQfinish(conn);
  }
--- 344,350 ----
  
  	ReceiveXlogStream(conn, startpos, starttli, NULL, basedir,
  					  stop_streaming, standby_message_timeout, ".partial",
! 					  fsync_interval, reply_fsync);
  
  	PQfinish(conn);
  }
***************
*** 376,381 **** main(int argc, char **argv)
--- 378,384 ----
  		{"no-password", no_argument, NULL, 'w'},
  		{"password", no_argument, NULL, 'W'},
  		{"status-interval", required_argument, NULL, 's'},
+ 		{"reply-fsync", no_argument, NULL, 'r'},
  		{"slot", required_argument, NULL, 'S'},
  		{"verbose", no_argument, NULL, 'v'},
  /* action */
***************
*** 406,412 **** main(int argc, char **argv)
  		}
  	}
  
! 	while ((c = getopt_long(argc, argv, "D:d:h:p:U:s:S:nF:wWv",
  							long_options, &option_index)) != -1)
  	{
  		switch (c)
--- 409,415 ----
  		}
  	}
  
! 	while ((c = getopt_long(argc, argv, "D:d:h:p:U:s:rS:nF:wWv",
  							long_options, &option_index)) != -1)
  	{
  		switch (c)
***************
*** 447,452 **** main(int argc, char **argv)
--- 450,458 ----
  					exit(1);
  				}
  				break;
+ 			case 'r':
+ 				reply_fsync = true;
+ 				break;
  			case 'S':
  				replication_slot = pg_strdup(optarg);
  				break;
*** a/src/bin/pg_basebackup/receivelog.c
--- b/src/bin/pg_basebackup/receivelog.c
***************
*** 38,44 **** static PGresult *HandleCopyStream(PGconn *conn, XLogRecPtr startpos,
  				 uint32 timeline, char *basedir,
  			   stream_stop_callback stream_stop, int standby_message_timeout,
  				  char *partial_suffix, XLogRecPtr *stoppos,
! 				  int fsync_interval);
  static int CopyStreamPoll(PGconn *conn, long timeout_ms);
  static int CopyStreamReceive(PGconn *conn, long timeout, char **buffer);
  static bool ProcessKeepaliveMsg(PGconn *conn, char *copybuf, int len,
--- 38,44 ----
  				 uint32 timeline, char *basedir,
  			   stream_stop_callback stream_stop, int standby_message_timeout,
  				  char *partial_suffix, XLogRecPtr *stoppos,
! 				  int fsync_interval, bool reply_fsync);
  static int CopyStreamPoll(PGconn *conn, long timeout_ms);
  static int CopyStreamReceive(PGconn *conn, long timeout, char **buffer);
  static bool ProcessKeepaliveMsg(PGconn *conn, char *copybuf, int len,
***************
*** 443,448 **** CheckServerVersionForStreaming(PGconn *conn)
--- 443,451 ----
   * fsync_interval controls how often we flush to the received WAL file,
   * in milliseconds.
   *
+  * If 'reply_fsync' is true, status packets sent to server as soon as
+  * after fsync.
+  *
   * Note: The log position *must* be at a log segment start!
   */
  bool
***************
*** 450,456 **** ReceiveXlogStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				  char *sysidentifier, char *basedir,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout, char *partial_suffix,
! 				  int fsync_interval)
  {
  	char		query[128];
  	char		slotcmd[128];
--- 453,459 ----
  				  char *sysidentifier, char *basedir,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout, char *partial_suffix,
! 				  int fsync_interval, bool reply_fsync)
  {
  	char		query[128];
  	char		slotcmd[128];
***************
*** 595,601 **** ReceiveXlogStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  		/* Stream the WAL */
  		res = HandleCopyStream(conn, startpos, timeline, basedir, stream_stop,
  							   standby_message_timeout, partial_suffix,
! 							   &stoppos, fsync_interval);
  		if (res == NULL)
  			goto error;
  
--- 598,604 ----
  		/* Stream the WAL */
  		res = HandleCopyStream(conn, startpos, timeline, basedir, stream_stop,
  							   standby_message_timeout, partial_suffix,
! 							   &stoppos, fsync_interval, reply_fsync);
  		if (res == NULL)
  			goto error;
  
***************
*** 760,770 **** static PGresult *
  HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				 char *basedir, stream_stop_callback stream_stop,
  				 int standby_message_timeout, char *partial_suffix,
! 				 XLogRecPtr *stoppos, int fsync_interval)
  {
  	char	   *copybuf = NULL;
  	int64		last_status = -1;
  	XLogRecPtr	blockpos = startpos;
  
  	still_sending = true;
  
--- 763,774 ----
  HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				 char *basedir, stream_stop_callback stream_stop,
  				 int standby_message_timeout, char *partial_suffix,
! 				 XLogRecPtr *stoppos, int fsync_interval, bool reply_fsync)
  {
  	char	   *copybuf = NULL;
  	int64		last_status = -1;
  	XLogRecPtr	blockpos = startpos;
+ 	XLogRecPtr	lastFeedbackFlushPosition = startpos;
  
  	still_sending = true;
  
***************
*** 807,820 **** HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  		/*
  		 * Potentially send a status message to the master
  		 */
! 		if (still_sending && standby_message_timeout > 0 &&
! 			feTimestampDifferenceExceeds(last_status, now,
! 										 standby_message_timeout))
  		{
  			/* Time to send feedback! */
  			if (!sendFeedback(conn, blockpos, now, false))
  				goto error;
  			last_status = now;
  		}
  
  		/*
--- 811,826 ----
  		/*
  		 * Potentially send a status message to the master
  		 */
! 		if ((still_sending && standby_message_timeout > 0 &&
! 			feTimestampDifferenceExceeds(last_status, now, standby_message_timeout)) ||
! 			(reply_fsync && lastFeedbackFlushPosition != lastFlushPosition))
  		{
  			/* Time to send feedback! */
  			if (!sendFeedback(conn, blockpos, now, false))
  				goto error;
  			last_status = now;
+ 			if (reply_fsync)
+ 				lastFeedbackFlushPosition = lastFlushPosition;
  		}
  
  		/*
*** a/src/bin/pg_basebackup/receivelog.h
--- b/src/bin/pg_basebackup/receivelog.h
***************
*** 31,36 **** extern bool ReceiveXlogStream(PGconn *conn,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout,
  				  char *partial_suffix,
! 				  int fsync_interval);
  
  #endif	/* RECEIVELOG_H */
--- 31,37 ----
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout,
  				  char *partial_suffix,
! 				  int fsync_interval,
! 				  bool reply_fsync);
  
  #endif	/* RECEIVELOG_H */

*** a/doc/src/sgml/ref/pg_receivexlog.sgml
--- b/doc/src/sgml/ref/pg_receivexlog.sgml
***************
*** 204,209 **** PostgreSQL documentation
--- 204,219 ----
       </varlistentry>
  
       <varlistentry>
+       <term><option>-N</></term>
+       <term><option>--no-fsync</></term>
+       <listitem>
+        <para>
+         WAL file is flushed only it has changed.
+        </para>
+       </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
        <term><option>-U <replaceable>username</replaceable></option></term>
        <term><option>--username=<replaceable class="parameter">username</replaceable></option></term>
        <listitem>
*** a/src/bin/pg_basebackup/pg_basebackup.c
--- b/src/bin/pg_basebackup/pg_basebackup.c
***************
*** 370,376 **** LogStreamerMain(logstreamer_param *param)
  	if (!ReceiveXlogStream(param->bgconn, param->startptr, param->timeline,
  						   param->sysidentifier, param->xlogdir,
  						   reached_end_position, standby_message_timeout,
! 						   NULL, 0))
  
  		/*
  		 * Any errors will already have been reported in the function process,
--- 370,376 ----
  	if (!ReceiveXlogStream(param->bgconn, param->startptr, param->timeline,
  						   param->sysidentifier, param->xlogdir,
  						   reached_end_position, standby_message_timeout,
! 						   NULL, true))
  
  		/*
  		 * Any errors will already have been reported in the function process,
*** a/src/bin/pg_basebackup/pg_receivexlog.c
--- b/src/bin/pg_basebackup/pg_receivexlog.c
***************
*** 36,46 **** static char *basedir = NULL;
  static int	verbose = 0;
  static int	noloop = 0;
  static int	standby_message_timeout = 10 * 1000;		/* 10 sec = default */
- static int	fsync_interval = 0; /* 0 = default */
  static volatile bool time_to_abort = false;
  static bool do_create_slot = false;
  static bool do_drop_slot = false;
! 
  
  static void usage(void);
  static DIR* get_destination_dir(char *dest_folder);
--- 36,45 ----
  static int	verbose = 0;
  static int	noloop = 0;
  static int	standby_message_timeout = 10 * 1000;		/* 10 sec = default */
  static volatile bool time_to_abort = false;
  static bool do_create_slot = false;
  static bool do_drop_slot = false;
! static bool	no_fsync = false;
  
  static void usage(void);
  static DIR* get_destination_dir(char *dest_folder);
***************
*** 66,76 **** usage(void)
  	printf(_("  %s [OPTION]...\n"), progname);
  	printf(_("\nOptions:\n"));
  	printf(_("  -D, --directory=DIR    receive transaction log files into this directory\n"));
- 	printf(_("  -F  --fsync-interval=SECS\n"
- 			 "                         time between fsyncs to transaction log files (default: %d)\n"), (fsync_interval / 1000));
  	printf(_("  -n, --no-loop          do not loop on connection lost\n"));
  	printf(_("  -s, --status-interval=SECS\n"
  			 "                         time between status packets sent to server (default: %d)\n"), (standby_message_timeout / 1000));
  	printf(_("  -S, --slot=SLOTNAME    replication slot to use\n"));
  	printf(_("  -v, --verbose          output verbose messages\n"));
  	printf(_("  -V, --version          output version information, then exit\n"));
--- 65,75 ----
  	printf(_("  %s [OPTION]...\n"), progname);
  	printf(_("\nOptions:\n"));
  	printf(_("  -D, --directory=DIR    receive transaction log files into this directory\n"));
  	printf(_("  -n, --no-loop          do not loop on connection lost\n"));
  	printf(_("  -s, --status-interval=SECS\n"
  			 "                         time between status packets sent to server (default: %d)\n"), (standby_message_timeout / 1000));
+ 	printf(_("  -N, --no-fsync         fsync only wal has changed\n"
+  			 "                         If you want to report the flush position to the server, should use -S option.\n"));
  	printf(_("  -S, --slot=SLOTNAME    replication slot to use\n"));
  	printf(_("  -v, --verbose          output verbose messages\n"));
  	printf(_("  -V, --version          output version information, then exit\n"));
***************
*** 343,349 **** StreamLog(void)
  
  	ReceiveXlogStream(conn, startpos, starttli, NULL, basedir,
  					  stop_streaming, standby_message_timeout, ".partial",
! 					  fsync_interval);
  
  	PQfinish(conn);
  	conn = NULL;
--- 342,348 ----
  
  	ReceiveXlogStream(conn, startpos, starttli, NULL, basedir,
  					  stop_streaming, standby_message_timeout, ".partial",
! 					  no_fsync);
  
  	PQfinish(conn);
  	conn = NULL;
***************
*** 374,383 **** main(int argc, char **argv)
  		{"port", required_argument, NULL, 'p'},
  		{"username", required_argument, NULL, 'U'},
  		{"no-loop", no_argument, NULL, 'n'},
- 		{"fsync-interval", required_argument, NULL, 'F'},
  		{"no-password", no_argument, NULL, 'w'},
  		{"password", no_argument, NULL, 'W'},
  		{"status-interval", required_argument, NULL, 's'},
  		{"slot", required_argument, NULL, 'S'},
  		{"verbose", no_argument, NULL, 'v'},
  /* action */
--- 373,382 ----
  		{"port", required_argument, NULL, 'p'},
  		{"username", required_argument, NULL, 'U'},
  		{"no-loop", no_argument, NULL, 'n'},
  		{"no-password", no_argument, NULL, 'w'},
  		{"password", no_argument, NULL, 'W'},
  		{"status-interval", required_argument, NULL, 's'},
+ 		{"no-fsync", no_argument, NULL, 'N'},
  		{"slot", required_argument, NULL, 'S'},
  		{"verbose", no_argument, NULL, 'v'},
  /* action */
***************
*** 408,414 **** main(int argc, char **argv)
  		}
  	}
  
! 	while ((c = getopt_long(argc, argv, "D:d:h:p:U:s:S:nF:wWv",
  							long_options, &option_index)) != -1)
  	{
  		switch (c)
--- 407,413 ----
  		}
  	}
  
! 	while ((c = getopt_long(argc, argv, "D:d:h:p:U:s:NS:nwWv",
  							long_options, &option_index)) != -1)
  	{
  		switch (c)
***************
*** 449,469 **** main(int argc, char **argv)
  					exit(1);
  				}
  				break;
  			case 'S':
  				replication_slot = pg_strdup(optarg);
  				break;
  			case 'n':
  				noloop = 1;
  				break;
- 		case 'F':
- 			fsync_interval = atoi(optarg) * 1000;
- 			if (fsync_interval < -1000)
- 			{
- 				fprintf(stderr, _("%s: invalid fsync interval \"%s\"\n"),
- 						progname, optarg);
- 				exit(1);
- 			}
- 			break;
  			case 'v':
  				verbose++;
  				break;
--- 448,462 ----
  					exit(1);
  				}
  				break;
+ 			case 'N':
+ 				no_fsync = true;
+ 				break;
  			case 'S':
  				replication_slot = pg_strdup(optarg);
  				break;
  			case 'n':
  				noloop = 1;
  				break;
  			case 'v':
  				verbose++;
  				break;
*** a/src/bin/pg_basebackup/receivelog.c
--- b/src/bin/pg_basebackup/receivelog.c
***************
*** 31,44 **** static char current_walfile_name[MAXPGPATH] = "";
  static bool reportFlushPosition = false;
  static XLogRecPtr lastFlushPosition = InvalidXLogRecPtr;
  
- static int64 last_fsync = -1;		/* timestamp of last WAL file flush */
  static bool still_sending = true;		/* feedback still needs to be sent? */
  
  static PGresult *HandleCopyStream(PGconn *conn, XLogRecPtr startpos,
  				 uint32 timeline, char *basedir,
  			   stream_stop_callback stream_stop, int standby_message_timeout,
  				  char *partial_suffix, XLogRecPtr *stoppos,
! 				  int fsync_interval);
  static int CopyStreamPoll(PGconn *conn, long timeout_ms);
  static int CopyStreamReceive(PGconn *conn, long timeout, char **buffer);
  static bool ProcessKeepaliveMsg(PGconn *conn, char *copybuf, int len,
--- 31,43 ----
  static bool reportFlushPosition = false;
  static XLogRecPtr lastFlushPosition = InvalidXLogRecPtr;
  
  static bool still_sending = true;		/* feedback still needs to be sent? */
  
  static PGresult *HandleCopyStream(PGconn *conn, XLogRecPtr startpos,
  				 uint32 timeline, char *basedir,
  			   stream_stop_callback stream_stop, int standby_message_timeout,
  				  char *partial_suffix, XLogRecPtr *stoppos,
! 				  bool no_fsync);
  static int CopyStreamPoll(PGconn *conn, long timeout_ms);
  static int CopyStreamReceive(PGconn *conn, long timeout, char **buffer);
  static bool ProcessKeepaliveMsg(PGconn *conn, char *copybuf, int len,
***************
*** 55,62 **** static bool CheckCopyStreamStop(PGconn *conn, XLogRecPtr blockpos,
  								stream_stop_callback stream_stop,
  								char *partial_suffix, XLogRecPtr *stoppos);
  static long CalculateCopyStreamSleeptime(int64 now, int standby_message_timeout,
! 										 int64 last_status, int fsync_interval,
! 										 XLogRecPtr blockpos);
  
  static bool ReadEndOfStreamingResult(PGresult *res, XLogRecPtr *startpos,
  						 uint32 *timeline);
--- 54,60 ----
  								stream_stop_callback stream_stop,
  								char *partial_suffix, XLogRecPtr *stoppos);
  static long CalculateCopyStreamSleeptime(int64 now, int standby_message_timeout,
! 										 int64 last_status, XLogRecPtr blockpos);
  
  static bool ReadEndOfStreamingResult(PGresult *res, XLogRecPtr *startpos,
  						 uint32 *timeline);
***************
*** 209,215 **** close_walfile(char *basedir, char *partial_suffix, XLogRecPtr pos)
  				progname, current_walfile_name, partial_suffix);
  
  	lastFlushPosition = pos;
- 	last_fsync = feGetCurrentTimestamp();
  	return true;
  }
  
--- 207,212 ----
***************
*** 440,447 **** CheckServerVersionForStreaming(PGconn *conn)
   * allows you to tell the difference between partial and completed files,
   * so that you can continue later where you left.
   *
!  * fsync_interval controls how often we flush to the received WAL file,
!  * in milliseconds.
   *
   * Note: The log position *must* be at a log segment start!
   */
--- 437,443 ----
   * allows you to tell the difference between partial and completed files,
   * so that you can continue later where you left.
   *
!  * If 'no_fsync' is true, fsync is only wal change.
   *
   * Note: The log position *must* be at a log segment start!
   */
***************
*** 450,456 **** ReceiveXlogStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				  char *sysidentifier, char *basedir,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout, char *partial_suffix,
! 				  int fsync_interval)
  {
  	char		query[128];
  	char		slotcmd[128];
--- 446,452 ----
  				  char *sysidentifier, char *basedir,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout, char *partial_suffix,
! 				  bool no_fsync)
  {
  	char		query[128];
  	char		slotcmd[128];
***************
*** 595,601 **** ReceiveXlogStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  		/* Stream the WAL */
  		res = HandleCopyStream(conn, startpos, timeline, basedir, stream_stop,
  							   standby_message_timeout, partial_suffix,
! 							   &stoppos, fsync_interval);
  		if (res == NULL)
  			goto error;
  
--- 591,597 ----
  		/* Stream the WAL */
  		res = HandleCopyStream(conn, startpos, timeline, basedir, stream_stop,
  							   standby_message_timeout, partial_suffix,
! 							   &stoppos, no_fsync);
  		if (res == NULL)
  			goto error;
  
***************
*** 760,770 **** static PGresult *
  HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				 char *basedir, stream_stop_callback stream_stop,
  				 int standby_message_timeout, char *partial_suffix,
! 				 XLogRecPtr *stoppos, int fsync_interval)
  {
  	char	   *copybuf = NULL;
  	int64		last_status = -1;
  	XLogRecPtr	blockpos = startpos;
  
  	still_sending = true;
  
--- 756,767 ----
  HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				 char *basedir, stream_stop_callback stream_stop,
  				 int standby_message_timeout, char *partial_suffix,
! 				 XLogRecPtr *stoppos, bool no_fsync)
  {
  	char	   *copybuf = NULL;
  	int64		last_status = -1;
  	XLogRecPtr	blockpos = startpos;
+ 	XLogRecPtr	lastFeedbackFlushPosition = startpos;
  
  	still_sending = true;
  
***************
*** 789,797 **** HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  		 */
  		if (lastFlushPosition < blockpos &&
  			walfile != -1 &&
! 			((fsync_interval > 0 &&
! 			  feTimestampDifferenceExceeds(last_fsync, now, fsync_interval)) ||
! 			 fsync_interval < 0))
  		{
  			if (fsync(walfile) != 0)
  			{
--- 786,792 ----
  		 */
  		if (lastFlushPosition < blockpos &&
  			walfile != -1 &&
! 			! no_fsync)
  		{
  			if (fsync(walfile) != 0)
  			{
***************
*** 801,827 **** HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  			}
  
  			lastFlushPosition = blockpos;
- 			last_fsync = now;
  		}
  
  		/*
  		 * Potentially send a status message to the master
  		 */
! 		if (still_sending && standby_message_timeout > 0 &&
! 			feTimestampDifferenceExceeds(last_status, now,
! 										 standby_message_timeout))
  		{
  			/* Time to send feedback! */
  			if (!sendFeedback(conn, blockpos, now, false))
  				goto error;
  			last_status = now;
  		}
  
  		/*
  		 * Calculate how long send/receive loops should sleep
  		 */
  		sleeptime = CalculateCopyStreamSleeptime(now, standby_message_timeout,
! 												 last_status, fsync_interval, blockpos);
  
  		r = CopyStreamReceive(conn, sleeptime, &copybuf);
  		while (r != 0)
--- 796,823 ----
  			}
  
  			lastFlushPosition = blockpos;
  		}
  
  		/*
  		 * Potentially send a status message to the master
  		 */
! 		if ((still_sending && standby_message_timeout > 0 &&
! 			feTimestampDifferenceExceeds(last_status, now, standby_message_timeout)) ||
! 			(! no_fsync && lastFeedbackFlushPosition != lastFlushPosition))
  		{
  			/* Time to send feedback! */
  			if (!sendFeedback(conn, blockpos, now, false))
  				goto error;
  			last_status = now;
+ 			if (! no_fsync)
+ 				lastFeedbackFlushPosition = lastFlushPosition;
  		}
  
  		/*
  		 * Calculate how long send/receive loops should sleep
  		 */
  		sleeptime = CalculateCopyStreamSleeptime(now, standby_message_timeout,
! 												 last_status, blockpos);
  
  		r = CopyStreamReceive(conn, sleeptime, &copybuf);
  		while (r != 0)
***************
*** 1244,1277 **** CheckCopyStreamStop(PGconn *conn, XLogRecPtr blockpos, uint32 timeline,
   */
  static long
  CalculateCopyStreamSleeptime(int64 now, int standby_message_timeout,
! 							 int64 last_status, int fsync_interval, XLogRecPtr blockpos)
  {
- 	int64		targettime = 0;
  	int64		status_targettime = 0;
- 	int64		fsync_targettime = 0;
  	long		sleeptime;
  
  	if (standby_message_timeout && still_sending)
  		status_targettime = last_status +
  			(standby_message_timeout - 1) * ((int64) 1000);
  
! 	if (fsync_interval > 0 && lastFlushPosition < blockpos)
! 		fsync_targettime = last_fsync +
! 			(fsync_interval - 1) * ((int64) 1000);
! 
! 	if ((status_targettime < fsync_targettime && status_targettime > 0) ||
! 		fsync_targettime == 0)
! 		targettime = status_targettime;
! 	else
! 		targettime = fsync_targettime;
! 
! 	if (targettime > 0)
  	{
  		long		secs;
  		int			usecs;
  
  		feTimestampDifference(now,
! 							  targettime,
  							  &secs,
  							  &usecs);
  		/* Always sleep at least 1 sec */
--- 1240,1261 ----
   */
  static long
  CalculateCopyStreamSleeptime(int64 now, int standby_message_timeout,
! 							 int64 last_status, XLogRecPtr blockpos)
  {
  	int64		status_targettime = 0;
  	long		sleeptime;
  
  	if (standby_message_timeout && still_sending)
  		status_targettime = last_status +
  			(standby_message_timeout - 1) * ((int64) 1000);
  
! 	if (status_targettime > 0)
  	{
  		long		secs;
  		int			usecs;
  
  		feTimestampDifference(now,
! 							  status_targettime,
  							  &secs,
  							  &usecs);
  		/* Always sleep at least 1 sec */
*** a/src/bin/pg_basebackup/receivelog.h
--- b/src/bin/pg_basebackup/receivelog.h
***************
*** 31,36 **** extern bool ReceiveXlogStream(PGconn *conn,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout,
  				  char *partial_suffix,
! 				  int fsync_interval);
  
  #endif	/* RECEIVELOG_H */
--- 31,36 ----
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout,
  				  char *partial_suffix,
! 				  bool no_fsync);
  
  #endif	/* RECEIVELOG_H */

*** a/doc/src/sgml/ref/pg_receivexlog.sgml
--- b/doc/src/sgml/ref/pg_receivexlog.sgml
***************
*** 49,54 **** PostgreSQL documentation
--- 49,61 ----
    </para>
  
    <para>
+    Unlike the standby's WAL receiver, <application>pg_receivexlog</>
+    flushes WAL data only when WAL file is closed, by default.
+    <literal>--synchronous</> option must be specified to flush WAL data
+    in real time and ensure it's safely flushed to disk.
+   </para>
+ 
+   <para>
     The transaction log is streamed over a regular
     <productname>PostgreSQL</productname> connection, and uses the replication
     protocol. The connection must be made with a superuser or a user
***************
*** 86,106 **** PostgreSQL documentation
       </varlistentry>
  
       <varlistentry>
-        <term><option>-F <replaceable class="parameter">interval</replaceable></option></term>
-        <term><option>--fsync-interval=<replaceable class="parameter">interval</replaceable></option></term>
-        <listitem>
-         <para>
-         Specifies the maximum time to issue sync commands to ensure the
-         received WAL file is safely flushed to disk, in seconds. The default
-         value is zero, which disables issuing fsyncs except when WAL file is
-         closed. If <literal>-1</literal> is specified, WAL file is flushed as
-         soon as possible, that is, as soon as there are WAL data which has
-         not been flushed yet.
-         </para>
-        </listitem>
-       </varlistentry>
- 
-      <varlistentry>
        <term><option>-n</option></term>
        <term><option>--no-loop</option></term>
        <listitem>
--- 93,98 ----
***************
*** 135,150 **** PostgreSQL documentation
           When this option is used, <application>pg_receivexlog</> will report
           a flush position to the server, indicating when each segment has been
           synchronized to disk so that the server can remove that segment if it
!          is not otherwise needed.  When using this parameter, it is important
!          to make sure that <application>pg_receivexlog</> cannot become the
!          synchronous standby through an incautious setting of
!          <xref linkend="guc-synchronous-standby-names">; it does not flush
!          data frequently enough for this to work correctly.
          </para>
        </listitem>
       </varlistentry>
  
       <varlistentry>
        <term><option>-v</option></term>
        <term><option>--verbose</option></term>
        <listitem>
--- 127,152 ----
           When this option is used, <application>pg_receivexlog</> will report
           a flush position to the server, indicating when each segment has been
           synchronized to disk so that the server can remove that segment if it
!          is not otherwise needed. <literal>--synchronous</literal> option must
!         be specified when making <application>pg_receivexlog</> run as
!         synchronous standby by using replication slot. Otherwise WAL data
!         cannot be flushed frequently enough for this to work correctly.
          </para>
        </listitem>
       </varlistentry>
  
       <varlistentry>
+       <term><option>--synchronous</option></term>
+       <listitem>
+        <para>
+         Issue sync commands as soon as there is WAL data which has not been
+         flushed yet. Also status packets are sent back to the server just after
+         WAL data is flushed whatever <literal>--status-interval</> is set to.
+        </para>
+       </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
        <term><option>-v</option></term>
        <term><option>--verbose</option></term>
        <listitem>
*** a/src/bin/pg_basebackup/pg_basebackup.c
--- b/src/bin/pg_basebackup/pg_basebackup.c
***************
*** 370,376 **** LogStreamerMain(logstreamer_param *param)
  	if (!ReceiveXlogStream(param->bgconn, param->startptr, param->timeline,
  						   param->sysidentifier, param->xlogdir,
  						   reached_end_position, standby_message_timeout,
! 						   NULL, 0))
  
  		/*
  		 * Any errors will already have been reported in the function process,
--- 370,376 ----
  	if (!ReceiveXlogStream(param->bgconn, param->startptr, param->timeline,
  						   param->sysidentifier, param->xlogdir,
  						   reached_end_position, standby_message_timeout,
! 						   NULL, false))
  
  		/*
  		 * Any errors will already have been reported in the function process,
*** a/src/bin/pg_basebackup/pg_receivexlog.c
--- b/src/bin/pg_basebackup/pg_receivexlog.c
***************
*** 36,45 **** static char *basedir = NULL;
  static int	verbose = 0;
  static int	noloop = 0;
  static int	standby_message_timeout = 10 * 1000;		/* 10 sec = default */
- static int	fsync_interval = 0; /* 0 = default */
  static volatile bool time_to_abort = false;
  static bool do_create_slot = false;
  static bool do_drop_slot = false;
  
  
  static void usage(void);
--- 36,45 ----
  static int	verbose = 0;
  static int	noloop = 0;
  static int	standby_message_timeout = 10 * 1000;		/* 10 sec = default */
  static volatile bool time_to_abort = false;
  static bool do_create_slot = false;
  static bool do_drop_slot = false;
+ static bool synchronous = false;
  
  
  static void usage(void);
***************
*** 66,77 **** usage(void)
  	printf(_("  %s [OPTION]...\n"), progname);
  	printf(_("\nOptions:\n"));
  	printf(_("  -D, --directory=DIR    receive transaction log files into this directory\n"));
- 	printf(_("  -F  --fsync-interval=SECS\n"
- 			 "                         time between fsyncs to transaction log files (default: %d)\n"), (fsync_interval / 1000));
  	printf(_("  -n, --no-loop          do not loop on connection lost\n"));
  	printf(_("  -s, --status-interval=SECS\n"
  			 "                         time between status packets sent to server (default: %d)\n"), (standby_message_timeout / 1000));
  	printf(_("  -S, --slot=SLOTNAME    replication slot to use\n"));
  	printf(_("  -v, --verbose          output verbose messages\n"));
  	printf(_("  -V, --version          output version information, then exit\n"));
  	printf(_("  -?, --help             show this help, then exit\n"));
--- 66,76 ----
  	printf(_("  %s [OPTION]...\n"), progname);
  	printf(_("\nOptions:\n"));
  	printf(_("  -D, --directory=DIR    receive transaction log files into this directory\n"));
  	printf(_("  -n, --no-loop          do not loop on connection lost\n"));
  	printf(_("  -s, --status-interval=SECS\n"
  			 "                         time between status packets sent to server (default: %d)\n"), (standby_message_timeout / 1000));
  	printf(_("  -S, --slot=SLOTNAME    replication slot to use\n"));
+ 	printf(_("      --synchronous      flush transaction log in real time\n"));
  	printf(_("  -v, --verbose          output verbose messages\n"));
  	printf(_("  -V, --version          output version information, then exit\n"));
  	printf(_("  -?, --help             show this help, then exit\n"));
***************
*** 343,349 **** StreamLog(void)
  
  	ReceiveXlogStream(conn, startpos, starttli, NULL, basedir,
  					  stop_streaming, standby_message_timeout, ".partial",
! 					  fsync_interval);
  
  	PQfinish(conn);
  	conn = NULL;
--- 342,348 ----
  
  	ReceiveXlogStream(conn, startpos, starttli, NULL, basedir,
  					  stop_streaming, standby_message_timeout, ".partial",
! 					  synchronous);
  
  	PQfinish(conn);
  	conn = NULL;
***************
*** 374,380 **** main(int argc, char **argv)
  		{"port", required_argument, NULL, 'p'},
  		{"username", required_argument, NULL, 'U'},
  		{"no-loop", no_argument, NULL, 'n'},
- 		{"fsync-interval", required_argument, NULL, 'F'},
  		{"no-password", no_argument, NULL, 'w'},
  		{"password", no_argument, NULL, 'W'},
  		{"status-interval", required_argument, NULL, 's'},
--- 373,378 ----
***************
*** 383,388 **** main(int argc, char **argv)
--- 381,387 ----
  /* action */
  		{"create-slot", no_argument, NULL, 1},
  		{"drop-slot", no_argument, NULL, 2},
+ 		{"synchronous", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
  	};
  
***************
*** 408,414 **** main(int argc, char **argv)
  		}
  	}
  
! 	while ((c = getopt_long(argc, argv, "D:d:h:p:U:s:S:nF:wWv",
  							long_options, &option_index)) != -1)
  	{
  		switch (c)
--- 407,413 ----
  		}
  	}
  
! 	while ((c = getopt_long(argc, argv, "D:d:h:p:U:s:S:nwWv",
  							long_options, &option_index)) != -1)
  	{
  		switch (c)
***************
*** 455,469 **** main(int argc, char **argv)
  			case 'n':
  				noloop = 1;
  				break;
- 		case 'F':
- 			fsync_interval = atoi(optarg) * 1000;
- 			if (fsync_interval < -1000)
- 			{
- 				fprintf(stderr, _("%s: invalid fsync interval \"%s\"\n"),
- 						progname, optarg);
- 				exit(1);
- 			}
- 			break;
  			case 'v':
  				verbose++;
  				break;
--- 454,459 ----
***************
*** 474,479 **** main(int argc, char **argv)
--- 464,472 ----
  			case 2:
  				do_drop_slot = true;
  				break;
+ 			case 3:
+ 				synchronous = true;
+ 				break;
  			default:
  
  				/*
*** a/src/bin/pg_basebackup/receivelog.c
--- b/src/bin/pg_basebackup/receivelog.c
***************
*** 31,44 **** static char current_walfile_name[MAXPGPATH] = "";
  static bool reportFlushPosition = false;
  static XLogRecPtr lastFlushPosition = InvalidXLogRecPtr;
  
- static int64 last_fsync = -1;		/* timestamp of last WAL file flush */
  static bool still_sending = true;		/* feedback still needs to be sent? */
  
  static PGresult *HandleCopyStream(PGconn *conn, XLogRecPtr startpos,
  				 uint32 timeline, char *basedir,
  			   stream_stop_callback stream_stop, int standby_message_timeout,
  				  char *partial_suffix, XLogRecPtr *stoppos,
! 				  int fsync_interval);
  static int CopyStreamPoll(PGconn *conn, long timeout_ms);
  static int CopyStreamReceive(PGconn *conn, long timeout, char **buffer);
  static bool ProcessKeepaliveMsg(PGconn *conn, char *copybuf, int len,
--- 31,43 ----
  static bool reportFlushPosition = false;
  static XLogRecPtr lastFlushPosition = InvalidXLogRecPtr;
  
  static bool still_sending = true;		/* feedback still needs to be sent? */
  
  static PGresult *HandleCopyStream(PGconn *conn, XLogRecPtr startpos,
  				 uint32 timeline, char *basedir,
  			   stream_stop_callback stream_stop, int standby_message_timeout,
  				  char *partial_suffix, XLogRecPtr *stoppos,
! 				  bool synchronous);
  static int CopyStreamPoll(PGconn *conn, long timeout_ms);
  static int CopyStreamReceive(PGconn *conn, long timeout, char **buffer);
  static bool ProcessKeepaliveMsg(PGconn *conn, char *copybuf, int len,
***************
*** 55,62 **** static bool CheckCopyStreamStop(PGconn *conn, XLogRecPtr blockpos,
  								stream_stop_callback stream_stop,
  								char *partial_suffix, XLogRecPtr *stoppos);
  static long CalculateCopyStreamSleeptime(int64 now, int standby_message_timeout,
! 										 int64 last_status, int fsync_interval,
! 										 XLogRecPtr blockpos);
  
  static bool ReadEndOfStreamingResult(PGresult *res, XLogRecPtr *startpos,
  						 uint32 *timeline);
--- 54,60 ----
  								stream_stop_callback stream_stop,
  								char *partial_suffix, XLogRecPtr *stoppos);
  static long CalculateCopyStreamSleeptime(int64 now, int standby_message_timeout,
! 										 int64 last_status);
  
  static bool ReadEndOfStreamingResult(PGresult *res, XLogRecPtr *startpos,
  						 uint32 *timeline);
***************
*** 209,215 **** close_walfile(char *basedir, char *partial_suffix, XLogRecPtr pos)
  				progname, current_walfile_name, partial_suffix);
  
  	lastFlushPosition = pos;
- 	last_fsync = feGetCurrentTimestamp();
  	return true;
  }
  
--- 207,212 ----
***************
*** 440,447 **** CheckServerVersionForStreaming(PGconn *conn)
   * allows you to tell the difference between partial and completed files,
   * so that you can continue later where you left.
   *
!  * fsync_interval controls how often we flush to the received WAL file,
!  * in milliseconds.
   *
   * Note: The log position *must* be at a log segment start!
   */
--- 437,444 ----
   * allows you to tell the difference between partial and completed files,
   * so that you can continue later where you left.
   *
!  * If 'synchronous' is true, the received WAL is flushed as soon as written,
!  * otherwise only when the WAL file is closed.
   *
   * Note: The log position *must* be at a log segment start!
   */
***************
*** 450,456 **** ReceiveXlogStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				  char *sysidentifier, char *basedir,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout, char *partial_suffix,
! 				  int fsync_interval)
  {
  	char		query[128];
  	char		slotcmd[128];
--- 447,453 ----
  				  char *sysidentifier, char *basedir,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout, char *partial_suffix,
! 				  bool synchronous)
  {
  	char		query[128];
  	char		slotcmd[128];
***************
*** 595,601 **** ReceiveXlogStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  		/* Stream the WAL */
  		res = HandleCopyStream(conn, startpos, timeline, basedir, stream_stop,
  							   standby_message_timeout, partial_suffix,
! 							   &stoppos, fsync_interval);
  		if (res == NULL)
  			goto error;
  
--- 592,598 ----
  		/* Stream the WAL */
  		res = HandleCopyStream(conn, startpos, timeline, basedir, stream_stop,
  							   standby_message_timeout, partial_suffix,
! 							   &stoppos, synchronous);
  		if (res == NULL)
  			goto error;
  
***************
*** 760,766 **** static PGresult *
  HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				 char *basedir, stream_stop_callback stream_stop,
  				 int standby_message_timeout, char *partial_suffix,
! 				 XLogRecPtr *stoppos, int fsync_interval)
  {
  	char	   *copybuf = NULL;
  	int64		last_status = -1;
--- 757,763 ----
  HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				 char *basedir, stream_stop_callback stream_stop,
  				 int standby_message_timeout, char *partial_suffix,
! 				 XLogRecPtr *stoppos, bool synchronous)
  {
  	char	   *copybuf = NULL;
  	int64		last_status = -1;
***************
*** 784,797 **** HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  		now = feGetCurrentTimestamp();
  
  		/*
! 		 * If fsync_interval has elapsed since last WAL flush and we've written
! 		 * some WAL data, flush them to disk.
  		 */
  		if (lastFlushPosition < blockpos &&
! 			walfile != -1 &&
! 			((fsync_interval > 0 &&
! 			  feTimestampDifferenceExceeds(last_fsync, now, fsync_interval)) ||
! 			 fsync_interval < 0))
  		{
  			if (fsync(walfile) != 0)
  			{
--- 781,791 ----
  		now = feGetCurrentTimestamp();
  
  		/*
! 		 * Issue sync command as soon as there are WAL data which
! 		 * has not been flushed yet if synchronous option is true.
  		 */
  		if (lastFlushPosition < blockpos &&
! 			walfile != -1 && synchronous)
  		{
  			if (fsync(walfile) != 0)
  			{
***************
*** 799,807 **** HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  						progname, current_walfile_name, strerror(errno));
  				goto error;
  			}
- 
  			lastFlushPosition = blockpos;
! 			last_fsync = now;
  		}
  
  		/*
--- 793,807 ----
  						progname, current_walfile_name, strerror(errno));
  				goto error;
  			}
  			lastFlushPosition = blockpos;
! 
! 			/*
! 			 * Send feedback so that the server sees the latest WAL locations
! 			 * immediately if synchronous option is true.
! 			 */
! 			if (!sendFeedback(conn, blockpos, now, false))
! 				goto error;
! 			last_status = now;
  		}
  
  		/*
***************
*** 821,827 **** HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  		 * Calculate how long send/receive loops should sleep
  		 */
  		sleeptime = CalculateCopyStreamSleeptime(now, standby_message_timeout,
! 												 last_status, fsync_interval, blockpos);
  
  		r = CopyStreamReceive(conn, sleeptime, &copybuf);
  		while (r != 0)
--- 821,827 ----
  		 * Calculate how long send/receive loops should sleep
  		 */
  		sleeptime = CalculateCopyStreamSleeptime(now, standby_message_timeout,
! 												 last_status);
  
  		r = CopyStreamReceive(conn, sleeptime, &copybuf);
  		while (r != 0)
***************
*** 1244,1277 **** CheckCopyStreamStop(PGconn *conn, XLogRecPtr blockpos, uint32 timeline,
   */
  static long
  CalculateCopyStreamSleeptime(int64 now, int standby_message_timeout,
! 							 int64 last_status, int fsync_interval, XLogRecPtr blockpos)
  {
- 	int64		targettime = 0;
  	int64		status_targettime = 0;
- 	int64		fsync_targettime = 0;
  	long		sleeptime;
  
  	if (standby_message_timeout && still_sending)
  		status_targettime = last_status +
  			(standby_message_timeout - 1) * ((int64) 1000);
  
! 	if (fsync_interval > 0 && lastFlushPosition < blockpos)
! 		fsync_targettime = last_fsync +
! 			(fsync_interval - 1) * ((int64) 1000);
! 
! 	if ((status_targettime < fsync_targettime && status_targettime > 0) ||
! 		fsync_targettime == 0)
! 		targettime = status_targettime;
! 	else
! 		targettime = fsync_targettime;
! 
! 	if (targettime > 0)
  	{
  		long		secs;
  		int			usecs;
  
  		feTimestampDifference(now,
! 							  targettime,
  							  &secs,
  							  &usecs);
  		/* Always sleep at least 1 sec */
--- 1244,1265 ----
   */
  static long
  CalculateCopyStreamSleeptime(int64 now, int standby_message_timeout,
! 							 int64 last_status)
  {
  	int64		status_targettime = 0;
  	long		sleeptime;
  
  	if (standby_message_timeout && still_sending)
  		status_targettime = last_status +
  			(standby_message_timeout - 1) * ((int64) 1000);
  
! 	if (status_targettime > 0)
  	{
  		long		secs;
  		int			usecs;
  
  		feTimestampDifference(now,
! 							  status_targettime,
  							  &secs,
  							  &usecs);
  		/* Always sleep at least 1 sec */
*** a/src/bin/pg_basebackup/receivelog.h
--- b/src/bin/pg_basebackup/receivelog.h
***************
*** 31,36 **** extern bool ReceiveXlogStream(PGconn *conn,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout,
  				  char *partial_suffix,
! 				  int fsync_interval);
  
  #endif	/* RECEIVELOG_H */
--- 31,36 ----
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout,
  				  char *partial_suffix,
! 				  bool synchronous);
  
  #endif	/* RECEIVELOG_H */

*** a/doc/src/sgml/ref/pg_receivexlog.sgml
--- b/doc/src/sgml/ref/pg_receivexlog.sgml
***************
*** 49,54 **** PostgreSQL documentation
--- 49,61 ----
    </para>
  
    <para>
+    Unlike the standby's WAL receiver, <application>pg_receivexlog</>
+    flushes WAL data only when WAL file is closed, by default.
+    <literal>--synchronous</> option must be specified to flush WAL data
+    in real time and ensure it's safely flushed to disk.
+   </para>
+ 
+   <para>
     The transaction log is streamed over a regular
     <productname>PostgreSQL</productname> connection, and uses the replication
     protocol. The connection must be made with a superuser or a user
***************
*** 86,106 **** PostgreSQL documentation
       </varlistentry>
  
       <varlistentry>
-        <term><option>-F <replaceable class="parameter">interval</replaceable></option></term>
-        <term><option>--fsync-interval=<replaceable class="parameter">interval</replaceable></option></term>
-        <listitem>
-         <para>
-         Specifies the maximum time to issue sync commands to ensure the
-         received WAL file is safely flushed to disk, in seconds. The default
-         value is zero, which disables issuing fsyncs except when WAL file is
-         closed. If <literal>-1</literal> is specified, WAL file is flushed as
-         soon as possible, that is, as soon as there are WAL data which has
-         not been flushed yet.
-         </para>
-        </listitem>
-       </varlistentry>
- 
-      <varlistentry>
        <term><option>-n</option></term>
        <term><option>--no-loop</option></term>
        <listitem>
--- 93,98 ----
***************
*** 135,150 **** PostgreSQL documentation
           When this option is used, <application>pg_receivexlog</> will report
           a flush position to the server, indicating when each segment has been
           synchronized to disk so that the server can remove that segment if it
!          is not otherwise needed.  When using this parameter, it is important
!          to make sure that <application>pg_receivexlog</> cannot become the
!          synchronous standby through an incautious setting of
!          <xref linkend="guc-synchronous-standby-names">; it does not flush
!          data frequently enough for this to work correctly.
          </para>
        </listitem>
       </varlistentry>
  
       <varlistentry>
        <term><option>-v</option></term>
        <term><option>--verbose</option></term>
        <listitem>
--- 127,152 ----
           When this option is used, <application>pg_receivexlog</> will report
           a flush position to the server, indicating when each segment has been
           synchronized to disk so that the server can remove that segment if it
!          is not otherwise needed. <literal>--synchronous</literal> option must
!          be specified when making <application>pg_receivexlog</> run as
!          synchronous standby by using replication slot. Otherwise WAL data
!          cannot be flushed frequently enough for this to work correctly.
          </para>
        </listitem>
       </varlistentry>
  
       <varlistentry>
+       <term><option>--synchronous</option></term>
+       <listitem>
+        <para>
+         Issue sync commands as soon as there is WAL data which has not been
+         flushed yet. Also status packets are sent back to the server just after
+         WAL data is flushed whatever <literal>--status-interval</> is set to.
+        </para>
+       </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
        <term><option>-v</option></term>
        <term><option>--verbose</option></term>
        <listitem>
*** a/src/bin/pg_basebackup/pg_basebackup.c
--- b/src/bin/pg_basebackup/pg_basebackup.c
***************
*** 370,376 **** LogStreamerMain(logstreamer_param *param)
  	if (!ReceiveXlogStream(param->bgconn, param->startptr, param->timeline,
  						   param->sysidentifier, param->xlogdir,
  						   reached_end_position, standby_message_timeout,
! 						   NULL, 0))
  
  		/*
  		 * Any errors will already have been reported in the function process,
--- 370,376 ----
  	if (!ReceiveXlogStream(param->bgconn, param->startptr, param->timeline,
  						   param->sysidentifier, param->xlogdir,
  						   reached_end_position, standby_message_timeout,
! 						   NULL, false))
  
  		/*
  		 * Any errors will already have been reported in the function process,
*** a/src/bin/pg_basebackup/pg_receivexlog.c
--- b/src/bin/pg_basebackup/pg_receivexlog.c
***************
*** 36,45 **** static char *basedir = NULL;
  static int	verbose = 0;
  static int	noloop = 0;
  static int	standby_message_timeout = 10 * 1000;		/* 10 sec = default */
- static int	fsync_interval = 0; /* 0 = default */
  static volatile bool time_to_abort = false;
  static bool do_create_slot = false;
  static bool do_drop_slot = false;
  
  
  static void usage(void);
--- 36,45 ----
  static int	verbose = 0;
  static int	noloop = 0;
  static int	standby_message_timeout = 10 * 1000;		/* 10 sec = default */
  static volatile bool time_to_abort = false;
  static bool do_create_slot = false;
  static bool do_drop_slot = false;
+ static bool synchronous = false;
  
  
  static void usage(void);
***************
*** 66,77 **** usage(void)
  	printf(_("  %s [OPTION]...\n"), progname);
  	printf(_("\nOptions:\n"));
  	printf(_("  -D, --directory=DIR    receive transaction log files into this directory\n"));
- 	printf(_("  -F  --fsync-interval=SECS\n"
- 			 "                         time between fsyncs to transaction log files (default: %d)\n"), (fsync_interval / 1000));
  	printf(_("  -n, --no-loop          do not loop on connection lost\n"));
  	printf(_("  -s, --status-interval=SECS\n"
  			 "                         time between status packets sent to server (default: %d)\n"), (standby_message_timeout / 1000));
  	printf(_("  -S, --slot=SLOTNAME    replication slot to use\n"));
  	printf(_("  -v, --verbose          output verbose messages\n"));
  	printf(_("  -V, --version          output version information, then exit\n"));
  	printf(_("  -?, --help             show this help, then exit\n"));
--- 66,76 ----
  	printf(_("  %s [OPTION]...\n"), progname);
  	printf(_("\nOptions:\n"));
  	printf(_("  -D, --directory=DIR    receive transaction log files into this directory\n"));
  	printf(_("  -n, --no-loop          do not loop on connection lost\n"));
  	printf(_("  -s, --status-interval=SECS\n"
  			 "                         time between status packets sent to server (default: %d)\n"), (standby_message_timeout / 1000));
  	printf(_("  -S, --slot=SLOTNAME    replication slot to use\n"));
+ 	printf(_("      --synchronous      flush transaction log immediately after writing\n"));
  	printf(_("  -v, --verbose          output verbose messages\n"));
  	printf(_("  -V, --version          output version information, then exit\n"));
  	printf(_("  -?, --help             show this help, then exit\n"));
***************
*** 343,349 **** StreamLog(void)
  
  	ReceiveXlogStream(conn, startpos, starttli, NULL, basedir,
  					  stop_streaming, standby_message_timeout, ".partial",
! 					  fsync_interval);
  
  	PQfinish(conn);
  	conn = NULL;
--- 342,348 ----
  
  	ReceiveXlogStream(conn, startpos, starttli, NULL, basedir,
  					  stop_streaming, standby_message_timeout, ".partial",
! 					  synchronous);
  
  	PQfinish(conn);
  	conn = NULL;
***************
*** 374,380 **** main(int argc, char **argv)
  		{"port", required_argument, NULL, 'p'},
  		{"username", required_argument, NULL, 'U'},
  		{"no-loop", no_argument, NULL, 'n'},
- 		{"fsync-interval", required_argument, NULL, 'F'},
  		{"no-password", no_argument, NULL, 'w'},
  		{"password", no_argument, NULL, 'W'},
  		{"status-interval", required_argument, NULL, 's'},
--- 373,378 ----
***************
*** 383,388 **** main(int argc, char **argv)
--- 381,387 ----
  /* action */
  		{"create-slot", no_argument, NULL, 1},
  		{"drop-slot", no_argument, NULL, 2},
+ 		{"synchronous", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
  	};
  
***************
*** 408,414 **** main(int argc, char **argv)
  		}
  	}
  
! 	while ((c = getopt_long(argc, argv, "D:d:h:p:U:s:S:nF:wWv",
  							long_options, &option_index)) != -1)
  	{
  		switch (c)
--- 407,413 ----
  		}
  	}
  
! 	while ((c = getopt_long(argc, argv, "D:d:h:p:U:s:S:nwWv",
  							long_options, &option_index)) != -1)
  	{
  		switch (c)
***************
*** 455,469 **** main(int argc, char **argv)
  			case 'n':
  				noloop = 1;
  				break;
- 		case 'F':
- 			fsync_interval = atoi(optarg) * 1000;
- 			if (fsync_interval < -1000)
- 			{
- 				fprintf(stderr, _("%s: invalid fsync interval \"%s\"\n"),
- 						progname, optarg);
- 				exit(1);
- 			}
- 			break;
  			case 'v':
  				verbose++;
  				break;
--- 454,459 ----
***************
*** 474,479 **** main(int argc, char **argv)
--- 464,472 ----
  			case 2:
  				do_drop_slot = true;
  				break;
+ 			case 3:
+ 				synchronous = true;
+ 				break;
  			default:
  
  				/*
*** a/src/bin/pg_basebackup/receivelog.c
--- b/src/bin/pg_basebackup/receivelog.c
***************
*** 31,44 **** static char current_walfile_name[MAXPGPATH] = "";
  static bool reportFlushPosition = false;
  static XLogRecPtr lastFlushPosition = InvalidXLogRecPtr;
  
- static int64 last_fsync = -1;		/* timestamp of last WAL file flush */
  static bool still_sending = true;		/* feedback still needs to be sent? */
  
  static PGresult *HandleCopyStream(PGconn *conn, XLogRecPtr startpos,
  				 uint32 timeline, char *basedir,
  			   stream_stop_callback stream_stop, int standby_message_timeout,
  				  char *partial_suffix, XLogRecPtr *stoppos,
! 				  int fsync_interval);
  static int CopyStreamPoll(PGconn *conn, long timeout_ms);
  static int CopyStreamReceive(PGconn *conn, long timeout, char **buffer);
  static bool ProcessKeepaliveMsg(PGconn *conn, char *copybuf, int len,
--- 31,43 ----
  static bool reportFlushPosition = false;
  static XLogRecPtr lastFlushPosition = InvalidXLogRecPtr;
  
  static bool still_sending = true;		/* feedback still needs to be sent? */
  
  static PGresult *HandleCopyStream(PGconn *conn, XLogRecPtr startpos,
  				 uint32 timeline, char *basedir,
  			   stream_stop_callback stream_stop, int standby_message_timeout,
  				  char *partial_suffix, XLogRecPtr *stoppos,
! 				  bool synchronous);
  static int CopyStreamPoll(PGconn *conn, long timeout_ms);
  static int CopyStreamReceive(PGconn *conn, long timeout, char **buffer);
  static bool ProcessKeepaliveMsg(PGconn *conn, char *copybuf, int len,
***************
*** 55,62 **** static bool CheckCopyStreamStop(PGconn *conn, XLogRecPtr blockpos,
  								stream_stop_callback stream_stop,
  								char *partial_suffix, XLogRecPtr *stoppos);
  static long CalculateCopyStreamSleeptime(int64 now, int standby_message_timeout,
! 										 int64 last_status, int fsync_interval,
! 										 XLogRecPtr blockpos);
  
  static bool ReadEndOfStreamingResult(PGresult *res, XLogRecPtr *startpos,
  						 uint32 *timeline);
--- 54,60 ----
  								stream_stop_callback stream_stop,
  								char *partial_suffix, XLogRecPtr *stoppos);
  static long CalculateCopyStreamSleeptime(int64 now, int standby_message_timeout,
! 										 int64 last_status);
  
  static bool ReadEndOfStreamingResult(PGresult *res, XLogRecPtr *startpos,
  						 uint32 *timeline);
***************
*** 209,215 **** close_walfile(char *basedir, char *partial_suffix, XLogRecPtr pos)
  				progname, current_walfile_name, partial_suffix);
  
  	lastFlushPosition = pos;
- 	last_fsync = feGetCurrentTimestamp();
  	return true;
  }
  
--- 207,212 ----
***************
*** 440,447 **** CheckServerVersionForStreaming(PGconn *conn)
   * allows you to tell the difference between partial and completed files,
   * so that you can continue later where you left.
   *
!  * fsync_interval controls how often we flush to the received WAL file,
!  * in milliseconds.
   *
   * Note: The log position *must* be at a log segment start!
   */
--- 437,444 ----
   * allows you to tell the difference between partial and completed files,
   * so that you can continue later where you left.
   *
!  * If 'synchronous' is true, the received WAL is flushed as soon as written,
!  * otherwise only when the WAL file is closed.
   *
   * Note: The log position *must* be at a log segment start!
   */
***************
*** 450,456 **** ReceiveXlogStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				  char *sysidentifier, char *basedir,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout, char *partial_suffix,
! 				  int fsync_interval)
  {
  	char		query[128];
  	char		slotcmd[128];
--- 447,453 ----
  				  char *sysidentifier, char *basedir,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout, char *partial_suffix,
! 				  bool synchronous)
  {
  	char		query[128];
  	char		slotcmd[128];
***************
*** 595,601 **** ReceiveXlogStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  		/* Stream the WAL */
  		res = HandleCopyStream(conn, startpos, timeline, basedir, stream_stop,
  							   standby_message_timeout, partial_suffix,
! 							   &stoppos, fsync_interval);
  		if (res == NULL)
  			goto error;
  
--- 592,598 ----
  		/* Stream the WAL */
  		res = HandleCopyStream(conn, startpos, timeline, basedir, stream_stop,
  							   standby_message_timeout, partial_suffix,
! 							   &stoppos, synchronous);
  		if (res == NULL)
  			goto error;
  
***************
*** 760,766 **** static PGresult *
  HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				 char *basedir, stream_stop_callback stream_stop,
  				 int standby_message_timeout, char *partial_suffix,
! 				 XLogRecPtr *stoppos, int fsync_interval)
  {
  	char	   *copybuf = NULL;
  	int64		last_status = -1;
--- 757,763 ----
  HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  				 char *basedir, stream_stop_callback stream_stop,
  				 int standby_message_timeout, char *partial_suffix,
! 				 XLogRecPtr *stoppos, bool synchronous)
  {
  	char	   *copybuf = NULL;
  	int64		last_status = -1;
***************
*** 784,797 **** HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  		now = feGetCurrentTimestamp();
  
  		/*
! 		 * If fsync_interval has elapsed since last WAL flush and we've written
! 		 * some WAL data, flush them to disk.
  		 */
! 		if (lastFlushPosition < blockpos &&
! 			walfile != -1 &&
! 			((fsync_interval > 0 &&
! 			  feTimestampDifferenceExceeds(last_fsync, now, fsync_interval)) ||
! 			 fsync_interval < 0))
  		{
  			if (fsync(walfile) != 0)
  			{
--- 781,790 ----
  		now = feGetCurrentTimestamp();
  
  		/*
! 		 * If synchronous option is true, issue sync command as soon as
! 		 * there are WAL data which has not been flushed yet.
  		 */
! 		if (synchronous && lastFlushPosition < blockpos && walfile != -1)
  		{
  			if (fsync(walfile) != 0)
  			{
***************
*** 799,807 **** HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  						progname, current_walfile_name, strerror(errno));
  				goto error;
  			}
- 
  			lastFlushPosition = blockpos;
! 			last_fsync = now;
  		}
  
  		/*
--- 792,806 ----
  						progname, current_walfile_name, strerror(errno));
  				goto error;
  			}
  			lastFlushPosition = blockpos;
! 
! 			/*
! 			 * Send feedback so that the server sees the latest WAL locations
! 			 * immediately.
! 			 */
! 			if (!sendFeedback(conn, blockpos, now, false))
! 				goto error;
! 			last_status = now;
  		}
  
  		/*
***************
*** 821,827 **** HandleCopyStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
  		 * Calculate how long send/receive loops should sleep
  		 */
  		sleeptime = CalculateCopyStreamSleeptime(now, standby_message_timeout,
! 												 last_status, fsync_interval, blockpos);
  
  		r = CopyStreamReceive(conn, sleeptime, &copybuf);
  		while (r != 0)
--- 820,826 ----
  		 * Calculate how long send/receive loops should sleep
  		 */
  		sleeptime = CalculateCopyStreamSleeptime(now, standby_message_timeout,
! 												 last_status);
  
  		r = CopyStreamReceive(conn, sleeptime, &copybuf);
  		while (r != 0)
***************
*** 1244,1277 **** CheckCopyStreamStop(PGconn *conn, XLogRecPtr blockpos, uint32 timeline,
   */
  static long
  CalculateCopyStreamSleeptime(int64 now, int standby_message_timeout,
! 							 int64 last_status, int fsync_interval, XLogRecPtr blockpos)
  {
- 	int64		targettime = 0;
  	int64		status_targettime = 0;
- 	int64		fsync_targettime = 0;
  	long		sleeptime;
  
  	if (standby_message_timeout && still_sending)
  		status_targettime = last_status +
  			(standby_message_timeout - 1) * ((int64) 1000);
  
! 	if (fsync_interval > 0 && lastFlushPosition < blockpos)
! 		fsync_targettime = last_fsync +
! 			(fsync_interval - 1) * ((int64) 1000);
! 
! 	if ((status_targettime < fsync_targettime && status_targettime > 0) ||
! 		fsync_targettime == 0)
! 		targettime = status_targettime;
! 	else
! 		targettime = fsync_targettime;
! 
! 	if (targettime > 0)
  	{
  		long		secs;
  		int			usecs;
  
  		feTimestampDifference(now,
! 							  targettime,
  							  &secs,
  							  &usecs);
  		/* Always sleep at least 1 sec */
--- 1243,1264 ----
   */
  static long
  CalculateCopyStreamSleeptime(int64 now, int standby_message_timeout,
! 							 int64 last_status)
  {
  	int64		status_targettime = 0;
  	long		sleeptime;
  
  	if (standby_message_timeout && still_sending)
  		status_targettime = last_status +
  			(standby_message_timeout - 1) * ((int64) 1000);
  
! 	if (status_targettime > 0)
  	{
  		long		secs;
  		int			usecs;
  
  		feTimestampDifference(now,
! 							  status_targettime,
  							  &secs,
  							  &usecs);
  		/* Always sleep at least 1 sec */
*** a/src/bin/pg_basebackup/receivelog.h
--- b/src/bin/pg_basebackup/receivelog.h
***************
*** 31,36 **** extern bool ReceiveXlogStream(PGconn *conn,
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout,
  				  char *partial_suffix,
! 				  int fsync_interval);
  
  #endif	/* RECEIVELOG_H */
--- 31,36 ----
  				  stream_stop_callback stream_stop,
  				  int standby_message_timeout,
  				  char *partial_suffix,
! 				  bool synchronous);
  
  #endif	/* RECEIVELOG_H */