Merge branch 'master' into stable

Author: za-arthur

src/backup.c

@@ -104,7 +104,8 @@ static int checkpoint_timeout(void);
 
 //static void backup_list_file(parray *files, const char *root, )
 static void parse_backup_filelist_filenames(parray *files, const char *root);
-static void wait_wal_lsn(XLogRecPtr lsn, bool wait_prev_segment);
+static void wait_wal_lsn(XLogRecPtr lsn, bool is_start_lsn,
+						 bool wait_prev_segment);
 static void wait_replica_wal_lsn(XLogRecPtr lsn, bool is_start_backup);
 static void make_pagemap_from_ptrack(parray *files);
 static void *StreamLog(void *arg);
@@ -717,7 +718,7 @@ do_backup_instance(void)
 	}
 
 	/* Run threads */
-	elog(LOG, "Start transfering data files");
+	elog(INFO, "Start transfering data files");
 	for (i = 0; i < num_threads; i++)
 	{
 		backup_files_arg *arg = &(threads_args[i]);
@@ -738,7 +739,7 @@ do_backup_instance(void)
 			backup_isok = false;
 	}
 	if (backup_isok)
-		elog(LOG, "Data files are transfered");
+		elog(INFO, "Data files are transfered");
 	else
 		elog(ERROR, "Data files transferring failed");
 
@@ -1070,8 +1071,8 @@ pg_start_backup(const char *label, bool smooth, pgBackup *backup)
 {
 	PGresult   *res;
 	const char *params[2];
-	uint32		xlogid;
-	uint32		xrecoff;
+	uint32		lsn_hi;
+	uint32		lsn_lo;
 	PGconn	   *conn;
 
 	params[0] = label;
@@ -1099,9 +1100,9 @@ pg_start_backup(const char *label, bool smooth, pgBackup *backup)
 	backup_in_progress = true;
 
 	/* Extract timeline and LSN from results of pg_start_backup() */
-	XLogDataFromLSN(PQgetvalue(res, 0, 0), &xlogid, &xrecoff);
+	XLogDataFromLSN(PQgetvalue(res, 0, 0), &lsn_hi, &lsn_lo);
 	/* Calculate LSN */
-	backup->start_lsn = (XLogRecPtr) ((uint64) xlogid << 32) | xrecoff;
+	backup->start_lsn = ((uint64) lsn_hi )<< 32 | lsn_lo;
 
 	PQclear(res);
 
@@ -1112,20 +1113,17 @@ pg_start_backup(const char *label, bool smooth, pgBackup *backup)
 		 */
 		pg_switch_wal(conn);
 
-	if (!stream_wal)
-	{
-		/*
-		 * Do not wait start_lsn for stream backup.
-		 * Because WAL streaming will start after pg_start_backup() in stream
-		 * mode.
-		 */
+	if (current.backup_mode == BACKUP_MODE_DIFF_PAGE)
 		/* In PAGE mode wait for current segment... */
-		if (current.backup_mode == BACKUP_MODE_DIFF_PAGE)
-			wait_wal_lsn(backup->start_lsn, false);
+		wait_wal_lsn(backup->start_lsn, true, false);
+	/*
+	 * Do not wait start_lsn for stream backup.
+	 * Because WAL streaming will start after pg_start_backup() in stream
+	 * mode.
+	 */
+	else if (!stream_wal)
 		/* ...for others wait for previous segment */
-		else
-			wait_wal_lsn(backup->start_lsn, true);
-	}
+		wait_wal_lsn(backup->start_lsn, true, true);
 
 	/* Wait for start_lsn to be replayed by replica */
 	if (backup->from_replica)
@@ -1443,16 +1441,20 @@ pg_ptrack_get_and_clear(Oid tablespace_oid, Oid db_oid, Oid rel_filenode,
  * If current backup started in stream mode wait for 'lsn' to be streamed in
  * 'pg_wal' directory.
  *
+ * If 'is_start_lsn' is true and backup mode is PAGE then we wait for 'lsn' to
+ * be archived in archive 'wal' directory regardless stream mode.
+ *
  * If 'wait_prev_segment' wait for previous segment.
  */
 static void
-wait_wal_lsn(XLogRecPtr lsn, bool wait_prev_segment)
+wait_wal_lsn(XLogRecPtr lsn, bool is_start_lsn, bool wait_prev_segment)
 {
 	TimeLineID	tli;
 	XLogSegNo	targetSegNo;
-	char		wal_dir[MAXPGPATH],
-				wal_segment_path[MAXPGPATH];
-	char		wal_segment[MAXFNAMELEN];
+	char		pg_wal_dir[MAXPGPATH];
+	char		wal_segment_path[MAXPGPATH],
+			   *wal_segment_dir,
+				wal_segment[MAXFNAMELEN];
 	bool		file_exists = false;
 	uint32		try_count = 0,
 				timeout;
@@ -1469,18 +1471,28 @@ wait_wal_lsn(XLogRecPtr lsn, bool wait_prev_segment)
 		targetSegNo--;
 	XLogFileName(wal_segment, tli, targetSegNo);
 
-	if (stream_wal)
+	/*
+	 * In pg_start_backup we wait for 'lsn' in 'pg_wal' directory iff it is
+	 * stream and non-page backup. Page backup needs archived WAL files, so we
+	 * wait for 'lsn' in archive 'wal' directory for page backups.
+	 *
+	 * In pg_stop_backup it depends only on stream_wal.
+	 */
+	if (stream_wal &&
+		(current.backup_mode != BACKUP_MODE_DIFF_PAGE || !is_start_lsn))
 	{
-		pgBackupGetPath2(&current, wal_dir, lengthof(wal_dir),
+		pgBackupGetPath2(&current, pg_wal_dir, lengthof(pg_wal_dir),
 						 DATABASE_DIR, PG_XLOG_DIR);
-		join_path_components(wal_segment_path, wal_dir, wal_segment);
+		join_path_components(wal_segment_path, pg_wal_dir, wal_segment);
+		wal_segment_dir = pg_wal_dir;
 
 		timeout = (uint32) checkpoint_timeout();
 		timeout = timeout + timeout * 0.1;
 	}
 	else
 	{
 		join_path_components(wal_segment_path, arclog_path, wal_segment);
+		wal_segment_dir = arclog_path;
 		timeout = archive_timeout;
 	}
 
@@ -1523,8 +1535,7 @@ wait_wal_lsn(XLogRecPtr lsn, bool wait_prev_segment)
 			/*
 			 * A WAL segment found. Check LSN on it.
 			 */
-			if ((stream_wal && wal_contains_lsn(wal_dir, lsn, tli)) ||
-				(!stream_wal && wal_contains_lsn(arclog_path, lsn, tli)))
+			if (wal_contains_lsn(wal_segment_dir, lsn, tli))
 				/* Target LSN was found */
 			{
 				elog(LOG, "Found LSN: %X/%X", (uint32) (lsn >> 32), (uint32) lsn);
@@ -1574,8 +1585,8 @@ wait_replica_wal_lsn(XLogRecPtr lsn, bool is_start_backup)
 	while (true)
 	{
 		PGresult   *res;
-		uint32		xlogid;
-		uint32		xrecoff;
+		uint32		lsn_hi;
+		uint32		lsn_lo;
 		XLogRecPtr	replica_lsn;
 
 		/*
@@ -1606,9 +1617,9 @@ wait_replica_wal_lsn(XLogRecPtr lsn, bool is_start_backup)
 		}
 
 		/* Extract timeline and LSN from result */
-		XLogDataFromLSN(PQgetvalue(res, 0, 0), &xlogid, &xrecoff);
+		XLogDataFromLSN(PQgetvalue(res, 0, 0), &lsn_hi, &lsn_lo);
 		/* Calculate LSN */
-		replica_lsn = (XLogRecPtr) ((uint64) xlogid << 32) | xrecoff;
+		replica_lsn = ((uint64) lsn_hi) << 32 | lsn_lo;
 		PQclear(res);
 
 		/* target lsn was replicated */
@@ -1642,10 +1653,10 @@ pg_stop_backup(pgBackup *backup)
 	PGconn		*conn;
 	PGresult	*res;
 	PGresult	*tablespace_map_content = NULL;
-	uint32		xlogid;
-	uint32		xrecoff;
+	uint32		lsn_hi;
+	uint32		lsn_lo;
 	XLogRecPtr	restore_lsn = InvalidXLogRecPtr;
-	int 		pg_stop_backup_timeout = 0;
+	int			pg_stop_backup_timeout = 0;
 	char		path[MAXPGPATH];
 	char		backup_label[MAXPGPATH];
 	FILE		*fp;
@@ -1688,6 +1699,10 @@ pg_stop_backup(pgBackup *backup)
 
 		res = pgut_execute(conn, "SELECT pg_catalog.pg_create_restore_point($1)",
 						   1, params);
+		/* Extract timeline and LSN from the result */
+		XLogDataFromLSN(PQgetvalue(res, 0, 0), &lsn_hi, &lsn_lo);
+		/* Calculate LSN */
+		restore_lsn = ((uint64) lsn_hi) << 32 | lsn_lo;
 		PQclear(res);
 	}
 
@@ -1720,7 +1735,6 @@ pg_stop_backup(pgBackup *backup)
 		}
 		else
 		{
-
 			stop_backup_query =	"SELECT"
 								" pg_catalog.txid_snapshot_xmax(pg_catalog.txid_current_snapshot()),"
 								" current_timestamp(0)::timestamptz,"
@@ -1739,6 +1753,8 @@ pg_stop_backup(pgBackup *backup)
 	 */
 	if (pg_stop_backup_is_sent && !in_cleanup)
 	{
+		res = NULL;
+
 		while (1)
 		{
 			if (!PQconsumeInput(conn) || PQisBusy(conn))
@@ -1780,8 +1796,11 @@ pg_stop_backup(pgBackup *backup)
 		{
 			switch (PQresultStatus(res))
 			{
+				/*
+				 * We should expect only PGRES_TUPLES_OK since pg_stop_backup
+				 * returns tuples.
+				 */
 				case PGRES_TUPLES_OK:
-				case PGRES_COMMAND_OK:
 					break;
 				default:
 					elog(ERROR, "query failed: %s query was: %s",
@@ -1793,9 +1812,9 @@ pg_stop_backup(pgBackup *backup)
 		backup_in_progress = false;
 
 		/* Extract timeline and LSN from results of pg_stop_backup() */
-		XLogDataFromLSN(PQgetvalue(res, 0, 2), &xlogid, &xrecoff);
+		XLogDataFromLSN(PQgetvalue(res, 0, 2), &lsn_hi, &lsn_lo);
 		/* Calculate LSN */
-		stop_backup_lsn = (XLogRecPtr) ((uint64) xlogid << 32) | xrecoff;
+		stop_backup_lsn = ((uint64) lsn_hi) << 32 | lsn_lo;
 
 		if (!XRecOffIsValid(stop_backup_lsn))
 		{
@@ -1912,7 +1931,7 @@ pg_stop_backup(pgBackup *backup)
 		 * Wait for stop_lsn to be archived or streamed.
 		 * We wait for stop_lsn in stream mode just in case.
 		 */
-		wait_wal_lsn(stop_backup_lsn, false);
+		wait_wal_lsn(stop_backup_lsn, false, false);
 
 		if (stream_wal)
 		{
@@ -2606,16 +2625,16 @@ get_last_ptrack_lsn(void)
 
 {
 	PGresult   *res;
-	uint32		xlogid;
-	uint32		xrecoff;
+	uint32		lsn_hi;
+	uint32		lsn_lo;
 	XLogRecPtr	lsn;
 
 	res = pgut_execute(backup_conn, "select pg_catalog.pg_ptrack_control_lsn()", 0, NULL);
 
 	/* Extract timeline and LSN from results of pg_start_backup() */
-	XLogDataFromLSN(PQgetvalue(res, 0, 0), &xlogid, &xrecoff);
+	XLogDataFromLSN(PQgetvalue(res, 0, 0), &lsn_hi, &lsn_lo);
 	/* Calculate LSN */
-	lsn = (XLogRecPtr) ((uint64) xlogid << 32) | xrecoff;
+	lsn = ((uint64) lsn_hi) << 32 | lsn_lo;
 
 	PQclear(res);
 	return lsn;