[PATCH] Relocation of tablespaces in pg_basebackup

*** doc/src/sgml/ref/pg_basebackup.sgml
--- doc/src/sgml/ref/pg_basebackup.sgml
***************
*** 138,143 **** PostgreSQL documentation
--- 138,155 ----
       </varlistentry>
  
       <varlistentry>
+       <term><option>-T <replaceable class="parameter">oid:tablespacedir</replaceable></option></term>
+       <term><option>--tablespace=<replaceable class="parameter">oid:tablespacedir</replaceable></option></term>
+       <listitem>
+        <para>
+         Specifies the location where tablespace with <replaceable>oid</replaceable>
+         is written, <replaceable>tablespacedir</replaceable> must be an absolute path.
+         This options can be specified multiple times for multiple tablespaces.
+        </para>
+       </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
        <term><option>-F <replaceable class="parameter">format</replaceable></option></term>
        <term><option>--format=<replaceable class="parameter">format</replaceable></option></term>
        <listitem>
***************
*** 530,536 **** PostgreSQL documentation
    <para>
     The way <productname>PostgreSQL</productname> manages tablespaces, the path
     for all additional tablespaces must be identical whenever a backup is
!    restored. The main data directory, however, is relocatable to any location.
    </para>
  
    <para>
--- 542,548 ----
    <para>
     The way <productname>PostgreSQL</productname> manages tablespaces, the path
     for all additional tablespaces must be identical whenever a backup is
!    restored, if <replaceable>--tablespace</replaceable> isn't specified.
    </para>
  
    <para>
***************
*** 570,575 **** PostgreSQL documentation
--- 582,595 ----
     (This command will fail if there are multiple tablespaces in the
     database.)
    </para>
+ 
+   <para>
+    To create a backup of a two-tablespace local database where tablespace
+    <literal>archive</literal> is written to <literal>./backup/archive</literal>
+ <screen>
+ <prompt>$</prompt> <userinput>pg_basebackup -D $(pwd)/backup/data -T archive:$(pwd)/backup/archive</userinput>
+ </screen>
+   </para>
   </refsect1>
  
   <refsect1>
*** src/bin/pg_basebackup/pg_basebackup.c
--- src/bin/pg_basebackup/pg_basebackup.c
***************
*** 33,40 ****
--- 33,54 ----
  #include "streamutil.h"
  
  
+ #define atooid(x)  ((Oid) strtoul((x), NULL, 10))
+ 
+ typedef struct TablespaceListCell {
+ 	struct TablespaceListCell *next;
+ 	Oid oid;
+ 	char path[1];
+ } TablespaceListCell;
+ 
+ typedef struct TablespaceList {
+ 	TablespaceListCell *head;
+ 	TablespaceListCell *tail;
+ } TablespaceList;
+ 
  /* Global options */
  static char *basedir = NULL;
+ static TablespaceList tablespace_locations = {NULL, NULL};
  static char *xlog_dir = "";
  static char	format = 'p';		/* p(lain)/t(ar) */
  static char *label = "pg_basebackup base backup";
***************
*** 86,91 **** static void BaseBackup(void);
--- 100,140 ----
  static bool reached_end_position(XLogRecPtr segendpos, uint32 timeline,
  					 bool segment_finished);
  
+ static const char *get_tablespace_location(Oid oid, const char *location);
+ static void update_tablespace_symlink(Oid oid, const char *location);
+ static bool tablespace_list_append(TablespaceList *list, const char *tablespace);
+ 
+ static bool
+ tablespace_list_append(TablespaceList *list, const char *tablespace)
+ {
+ 	TablespaceListCell *cell;
+ 	char *path;
+ 	Oid oid = atooid(tablespace);
+ 
+ 	if (!oid)
+ 		return false;
+ 
+ 	path = strstr(tablespace, ":/");
+ 	if (!path)
+ 		return false;
+ 	path++;
+ 
+ 	cell = (TablespaceListCell *) pg_malloc(sizeof(TablespaceListCell) + strlen(path));
+ 
+ 	cell->next = NULL;
+ 	cell->oid = oid;
+ 	strcpy(cell->path, path);
+ 
+ 	if (list->tail)
+ 		list->tail->next = cell;
+ 	else
+ 		list->head = cell;
+ 	list->tail = cell;
+ 
+ 	return true;
+ }
+ 
+ 
  #ifdef HAVE_LIBZ
  static const char *
  get_gz_error(gzFile gzf)
***************
*** 110,115 **** usage(void)
--- 159,166 ----
  	printf(_("  %s [OPTION]...\n"), progname);
  	printf(_("\nOptions controlling the output:\n"));
  	printf(_("  -D, --pgdata=DIRECTORY receive base backup into directory\n"));
+ 	printf(_("  -T, --tablespace=OID:LOCATION\n"
+ 			 "                         Specify tablespace oid and its absolute location\n"));
  	printf(_("  -F, --format=p|t       output format (plain (default), tar)\n"));
  	printf(_("  -R, --write-recovery-conf\n"
  			 "                         write recovery.conf after backup\n"));
***************
*** 861,874 **** ReceiveTarFile(PGconn *conn, PGresult *res, int rownum)
  }
  
  /*
   * Receive a tar format stream from the connection to the server, and unpack
   * the contents of it into a directory. Only files, directories and
   * symlinks are supported, no other kinds of special files.
   *
   * If the data is for the main data directory, it will be restored in the
   * specified directory. If it's for another tablespace, it will be restored
!  * in the original directory, since relocation of tablespaces is not
!  * supported.
   */
  static void
  ReceiveAndUnpackTarFile(PGconn *conn, PGresult *res, int rownum)
--- 912,967 ----
  }
  
  /*
+  * Retrieve tablespace location, either relocated or original depending on
+  * whether -T oid:tablespacedir was passed or not.
+  */
+ static const char *
+ get_tablespace_location(Oid oid, const char *location)
+ {
+ 	TablespaceListCell *cell;
+ 
+ 	for (cell = tablespace_locations.head; cell; cell = cell->next)
+ 		if (oid == cell->oid)
+ 			return cell->path;
+ 
+ 	return location;
+ }
+ 
+ /*
+  * Update symlinks to reflect relocated tablespace, only applied if
+  * tablespace isn't in its original location.
+  */
+ static void
+ update_tablespace_symlink(Oid oid, const char *location)
+ {
+ 	const char *new_location = get_tablespace_location(oid, location);
+ 	if (strcmp(new_location, location) != 0)
+ 	{
+ 		char linkloc[MAXPGPATH];
+ 		snprintf(linkloc, sizeof(linkloc), "%s/pg_tblspc/%d", basedir, oid);
+ 		if (unlink(linkloc) < 0 && errno != ENOENT)
+ 		{
+ 			fprintf(stderr, _("%s: unable to remove \"%s\": %s"),
+ 					progname, linkloc, strerror(errno));
+ 			disconnect_and_exit(1);
+ 		}
+ 		if (symlink(new_location, linkloc) < 0)
+ 		{
+ 			fprintf(stderr, _("%s: unable to create symlink \"%s\": %s"),
+ 					progname, linkloc, strerror(errno));
+ 			disconnect_and_exit(1);
+ 		}
+ 	}
+ }
+ 
+ /*
   * Receive a tar format stream from the connection to the server, and unpack
   * the contents of it into a directory. Only files, directories and
   * symlinks are supported, no other kinds of special files.
   *
   * If the data is for the main data directory, it will be restored in the
   * specified directory. If it's for another tablespace, it will be restored
!  * in the original directory, if tablespace relocation is not enabled.
   */
  static void
  ReceiveAndUnpackTarFile(PGconn *conn, PGresult *res, int rownum)
***************
*** 884,890 **** ReceiveAndUnpackTarFile(PGconn *conn, PGresult *res, int rownum)
  	if (basetablespace)
  		strcpy(current_path, basedir);
  	else
! 		strcpy(current_path, PQgetvalue(res, rownum, 1));
  
  	/*
  	 * Get the COPY data
--- 977,987 ----
  	if (basetablespace)
  		strcpy(current_path, basedir);
  	else
! 	{
! 		strcpy(current_path,
! 			   get_tablespace_location(atooid(PQgetvalue(res, rownum, 0)),
! 									   PQgetvalue(res, rownum, 1)));
! 	}
  
  	/*
  	 * Get the COPY data
***************
*** 1465,1471 **** BaseBackup(void)
  		 * we do anything anyway.
  		 */
  		if (format == 'p' && !PQgetisnull(res, i, 1))
! 			verify_dir_is_empty_or_create(PQgetvalue(res, i, 1));
  	}
  
  	/*
--- 1562,1572 ----
  		 * we do anything anyway.
  		 */
  		if (format == 'p' && !PQgetisnull(res, i, 1))
! 		{
! 			char *path = (char *) get_tablespace_location(atooid(PQgetvalue(res, i, 0)),
! 														  PQgetvalue(res, i, 1));
! 			verify_dir_is_empty_or_create(path);
! 		}
  	}
  
  	/*
***************
*** 1507,1512 **** BaseBackup(void)
--- 1608,1629 ----
  		progress_report(PQntuples(res), NULL);
  		fprintf(stderr, "\n");	/* Need to move to next line */
  	}
+ 
+ 	if (format == 'p' && tablespace_locations.head != NULL)
+ 	{
+ #ifdef HAVE_SYMLINK
+ 		for (i = 0; i < PQntuples(res); i++)
+ 		{
+ 			int tblspc_oid = atooid(PQgetvalue(res, i, 0));
+ 			if (tblspc_oid)
+ 				update_tablespace_symlink(tblspc_oid, PQgetvalue(res, i, 1));
+ 		}
+ #else
+ 		fprintf(stderr, _("%s: not updating pg_tblspc with new tablespace relocation\n"),
+ 				progname);
+ #endif
+ 	}
+ 
  	PQclear(res);
  
  	/*
***************
*** 1655,1660 **** main(int argc, char **argv)
--- 1772,1778 ----
  		{"help", no_argument, NULL, '?'},
  		{"version", no_argument, NULL, 'V'},
  		{"pgdata", required_argument, NULL, 'D'},
+ 		{"tablespace", required_argument, NULL, 'T'},
  		{"format", required_argument, NULL, 'F'},
  		{"checkpoint", required_argument, NULL, 'c'},
  		{"write-recovery-conf", no_argument, NULL, 'R'},
***************
*** 1697,1703 **** main(int argc, char **argv)
  		}
  	}
  
! 	while ((c = getopt_long(argc, argv, "D:F:RxX:l:zZ:d:c:h:p:U:s:wWvP",
  							long_options, &option_index)) != -1)
  	{
  		switch (c)
--- 1815,1821 ----
  		}
  	}
  
! 	while ((c = getopt_long(argc, argv, "D:T:F:RxX:l:zZ:d:c:h:p:U:s:wWvP",
  							long_options, &option_index)) != -1)
  	{
  		switch (c)
***************
*** 1705,1710 **** main(int argc, char **argv)
--- 1823,1837 ----
  			case 'D':
  				basedir = pg_strdup(optarg);
  				break;
+ 			case 'T':
+ 				if (!tablespace_list_append(&tablespace_locations, optarg))
+ 				{
+ 					fprintf(stderr,
+ 							_("%s: invalid tablespace format \"%s\", must be \"oid:/absolute-path\"\n"),
+ 							progname, optarg);
+ 					exit(1);
+ 				}
+ 				break;
  			case 'F':
  				if (strcmp(optarg, "p") == 0 || strcmp(optarg, "plain") == 0)
  					format = 'p';

commit 8d649148205cf16cee008b4a118654af86b67a0a
Author: Steeve Lennmark <steevel@handeldsbanken.se>
Date:   Thu Jan 9 20:45:26 2014 +0000

    Add support for relocating tablespaces
    
    This is done by mapping old and new tablespace location using the format
    old_dir:new_dir.

diff --git doc/src/sgml/ref/pg_basebackup.sgml doc/src/sgml/ref/pg_basebackup.sgml
index c379df5..cad57ba 100644
--- doc/src/sgml/ref/pg_basebackup.sgml
+++ doc/src/sgml/ref/pg_basebackup.sgml
@@ -138,6 +138,18 @@ PostgreSQL documentation
      </varlistentry>
 
      <varlistentry>
+      <term><option>-T <replaceable class="parameter">oid:tablespacedir</replaceable></option></term>
+      <term><option>--tablespace=<replaceable class="parameter">oid:tablespacedir</replaceable></option></term>
+      <listitem>
+       <para>
+        Specifies the location where tablespace with <replaceable>oid</replaceable>
+        is written, <replaceable>tablespacedir</replaceable> must be an absolute path.
+        This options can be specified multiple times for multiple tablespaces.
+       </para>
+      </listitem>
+     </varlistentry>
+
+     <varlistentry>
       <term><option>-F <replaceable class="parameter">format</replaceable></option></term>
       <term><option>--format=<replaceable class="parameter">format</replaceable></option></term>
       <listitem>
@@ -530,7 +542,7 @@ PostgreSQL documentation
   <para>
    The way <productname>PostgreSQL</productname> manages tablespaces, the path
    for all additional tablespaces must be identical whenever a backup is
-   restored. The main data directory, however, is relocatable to any location.
+   restored, if <replaceable>--tablespace</replaceable> isn't specified.
   </para>
 
   <para>
@@ -570,6 +582,14 @@ PostgreSQL documentation
    (This command will fail if there are multiple tablespaces in the
    database.)
   </para>
+
+  <para>
+   To create a backup of a two-tablespace local database where tablespace
+   <literal>archive</literal> is written to <literal>./backup/archive</literal>
+<screen>
+<prompt>$</prompt> <userinput>pg_basebackup -D $(pwd)/backup/data -T archive:$(pwd)/backup/archive</userinput>
+</screen>
+  </para>
  </refsect1>
 
  <refsect1>
diff --git src/bin/pg_basebackup/pg_basebackup.c src/bin/pg_basebackup/pg_basebackup.c
index 9d13d57..498ba78 100644
--- src/bin/pg_basebackup/pg_basebackup.c
+++ src/bin/pg_basebackup/pg_basebackup.c
@@ -33,8 +33,24 @@
 #include "streamutil.h"
 
 
+#define atooid(x)  ((Oid) strtoul((x), NULL, 10))
+
+typedef struct TablespaceListCell
+{
+	struct TablespaceListCell *next;
+	char  *old_dir;
+	char  *new_dir;
+} TablespaceListCell;
+
+typedef struct TablespaceList
+{
+	TablespaceListCell *head;
+	TablespaceListCell *tail;
+} TablespaceList;
+
 /* Global options */
 static char *basedir = NULL;
+static TablespaceList tablespace_dirs = {NULL, NULL};
 static char *xlog_dir = "";
 static char	format = 'p';		/* p(lain)/t(ar) */
 static char *label = "pg_basebackup base backup";
@@ -86,6 +102,37 @@ static void BaseBackup(void);
 static bool reached_end_position(XLogRecPtr segendpos, uint32 timeline,
 					 bool segment_finished);
 
+static const char *get_tablespace_dir(const char *dir);
+static void update_tablespace_symlink(Oid oid, const char *new_dir);
+static bool tablespace_list_append(TablespaceList *list, char *tablespace);
+
+static bool
+tablespace_list_append(TablespaceList *list, char *tablespace)
+{
+	TablespaceListCell *cell;
+	char *token;
+
+	if (!(token = strtok(tablespace, ":")))
+		return false;
+
+	cell = (TablespaceListCell *) pg_malloc(sizeof(TablespaceListCell));
+	cell->next = NULL;
+	cell->old_dir = pg_strdup(token);
+
+	if (!(token = strtok(NULL, ":")) || token[0] != '/')
+		return false;
+	cell->new_dir = pg_strdup(token);
+
+	if (list->tail)
+		list->tail->next = cell;
+	else
+		list->head = cell;
+	list->tail = cell;
+
+	return true;
+}
+
+
 #ifdef HAVE_LIBZ
 static const char *
 get_gz_error(gzFile gzf)
@@ -110,6 +157,8 @@ usage(void)
 	printf(_("  %s [OPTION]...\n"), progname);
 	printf(_("\nOptions controlling the output:\n"));
 	printf(_("  -D, --pgdata=DIRECTORY receive base backup into directory\n"));
+	printf(_("  -T, --tablespace=OLDDIR:NEWDIR\n"
+			 "                         relocate tablespace olddir to newdir\n"));
 	printf(_("  -F, --format=p|t       output format (plain (default), tar)\n"));
 	printf(_("  -R, --write-recovery-conf\n"
 			 "                         write recovery.conf after backup\n"));
@@ -861,14 +910,56 @@ ReceiveTarFile(PGconn *conn, PGresult *res, int rownum)
 }
 
 /*
+ * Retrieve tablespace path, either relocated or original depending on
+ * whether -T old_dir:new_dir was passed or not.
+ */
+static const char *
+get_tablespace_dir(const char *dir)
+{
+	TablespaceListCell *cell;
+
+	for (cell = tablespace_dirs.head; cell; cell = cell->next)
+		if (strcmp(dir, cell->old_dir) == 0)
+			return cell->new_dir;
+
+	return dir;
+}
+
+/*
+ * Update symlinks to reflect relocated tablespace, only applied if
+ * tablespace isn't in its original location.
+ */
+static void
+update_tablespace_symlink(Oid oid, const char *old_dir)
+{
+	const char *new_dir = get_tablespace_dir(old_dir);
+	if (strcmp(old_dir, new_dir) != 0)
+	{
+		char linkloc[MAXPGPATH];
+		snprintf(linkloc, sizeof(linkloc), "%s/pg_tblspc/%d", basedir, oid);
+		if (unlink(linkloc) < 0 && errno != ENOENT)
+		{
+			fprintf(stderr, _("%s: unable to remove \"%s\": %s"),
+					progname, linkloc, strerror(errno));
+			disconnect_and_exit(1);
+		}
+		if (symlink(new_dir, linkloc) < 0)
+		{
+			fprintf(stderr, _("%s: unable to create symlink \"%s\": %s"),
+					progname, linkloc, strerror(errno));
+			disconnect_and_exit(1);
+		}
+	}
+}
+
+/*
  * Receive a tar format stream from the connection to the server, and unpack
  * the contents of it into a directory. Only files, directories and
  * symlinks are supported, no other kinds of special files.
  *
  * If the data is for the main data directory, it will be restored in the
  * specified directory. If it's for another tablespace, it will be restored
- * in the original directory, since relocation of tablespaces is not
- * supported.
+ * in the original directory, if tablespace relocation is not enabled.
  */
 static void
 ReceiveAndUnpackTarFile(PGconn *conn, PGresult *res, int rownum)
@@ -884,7 +975,7 @@ ReceiveAndUnpackTarFile(PGconn *conn, PGresult *res, int rownum)
 	if (basetablespace)
 		strcpy(current_path, basedir);
 	else
-		strcpy(current_path, PQgetvalue(res, rownum, 1));
+		strcpy(current_path, get_tablespace_dir(PQgetvalue(res, rownum, 1)));
 
 	/*
 	 * Get the COPY data
@@ -1465,7 +1556,10 @@ BaseBackup(void)
 		 * we do anything anyway.
 		 */
 		if (format == 'p' && !PQgetisnull(res, i, 1))
-			verify_dir_is_empty_or_create(PQgetvalue(res, i, 1));
+		{
+			char *path = (char *) get_tablespace_dir(PQgetvalue(res, i, 1));
+			verify_dir_is_empty_or_create(path);
+		}
 	}
 
 	/*
@@ -1507,6 +1601,22 @@ BaseBackup(void)
 		progress_report(PQntuples(res), NULL);
 		fprintf(stderr, "\n");	/* Need to move to next line */
 	}
+
+	if (format == 'p' && tablespace_dirs.head != NULL)
+	{
+#ifdef HAVE_SYMLINK
+		for (i = 0; i < PQntuples(res); i++)
+		{
+			Oid tblspc_oid = atooid(PQgetvalue(res, i, 0));
+			if (tblspc_oid)
+				update_tablespace_symlink(tblspc_oid, PQgetvalue(res, i, 1));
+		}
+#else
+		fprintf(stderr, _("%s: not updating pg_tblspc with new tablespace relocation\n"),
+				progname);
+#endif
+	}
+
 	PQclear(res);
 
 	/*
@@ -1655,6 +1765,7 @@ main(int argc, char **argv)
 		{"help", no_argument, NULL, '?'},
 		{"version", no_argument, NULL, 'V'},
 		{"pgdata", required_argument, NULL, 'D'},
+		{"tablespace", required_argument, NULL, 'T'},
 		{"format", required_argument, NULL, 'F'},
 		{"checkpoint", required_argument, NULL, 'c'},
 		{"write-recovery-conf", no_argument, NULL, 'R'},
@@ -1697,7 +1808,7 @@ main(int argc, char **argv)
 		}
 	}
 
-	while ((c = getopt_long(argc, argv, "D:F:RxX:l:zZ:d:c:h:p:U:s:wWvP",
+	while ((c = getopt_long(argc, argv, "D:T:F:RxX:l:zZ:d:c:h:p:U:s:wWvP",
 							long_options, &option_index)) != -1)
 	{
 		switch (c)
@@ -1705,6 +1816,15 @@ main(int argc, char **argv)
 			case 'D':
 				basedir = pg_strdup(optarg);
 				break;
+			case 'T':
+				if (!tablespace_list_append(&tablespace_dirs, optarg))
+				{
+					fprintf(stderr,
+							_("%s: invalid tablespace format \"%s\", must be \"old_dir:/absolute-path\"\n"),
+							progname, optarg);
+					exit(1);
+				}
+				break;
 			case 'F':
 				if (strcmp(optarg, "p") == 0 || strcmp(optarg, "plain") == 0)
 					format = 'p';

commit ee9fab893d9689fffea229ed6be22d13721a1813
Author: Steeve Lennmark <steevel@handeldsbanken.se>
Date:   Thu Jan 9 20:45:26 2014 +0000

    Add support for relocating tablespaces
    
    This is done by mapping old and new tablespace location using the format
    old_dir:new_dir. This also accounts for directory names containing
    colons.

diff --git doc/src/sgml/ref/pg_basebackup.sgml doc/src/sgml/ref/pg_basebackup.sgml
index c379df5..cad57ba 100644
--- doc/src/sgml/ref/pg_basebackup.sgml
+++ doc/src/sgml/ref/pg_basebackup.sgml
@@ -138,6 +138,18 @@ PostgreSQL documentation
      </varlistentry>
 
      <varlistentry>
+      <term><option>-T <replaceable class="parameter">oid:tablespacedir</replaceable></option></term>
+      <term><option>--tablespace=<replaceable class="parameter">oid:tablespacedir</replaceable></option></term>
+      <listitem>
+       <para>
+        Specifies the location where tablespace with <replaceable>oid</replaceable>
+        is written, <replaceable>tablespacedir</replaceable> must be an absolute path.
+        This options can be specified multiple times for multiple tablespaces.
+       </para>
+      </listitem>
+     </varlistentry>
+
+     <varlistentry>
       <term><option>-F <replaceable class="parameter">format</replaceable></option></term>
       <term><option>--format=<replaceable class="parameter">format</replaceable></option></term>
       <listitem>
@@ -530,7 +542,7 @@ PostgreSQL documentation
   <para>
    The way <productname>PostgreSQL</productname> manages tablespaces, the path
    for all additional tablespaces must be identical whenever a backup is
-   restored. The main data directory, however, is relocatable to any location.
+   restored, if <replaceable>--tablespace</replaceable> isn't specified.
   </para>
 
   <para>
@@ -570,6 +582,14 @@ PostgreSQL documentation
    (This command will fail if there are multiple tablespaces in the
    database.)
   </para>
+
+  <para>
+   To create a backup of a two-tablespace local database where tablespace
+   <literal>archive</literal> is written to <literal>./backup/archive</literal>
+<screen>
+<prompt>$</prompt> <userinput>pg_basebackup -D $(pwd)/backup/data -T archive:$(pwd)/backup/archive</userinput>
+</screen>
+  </para>
  </refsect1>
 
  <refsect1>
diff --git src/bin/pg_basebackup/pg_basebackup.c src/bin/pg_basebackup/pg_basebackup.c
index 9d13d57..e3770cb 100644
--- src/bin/pg_basebackup/pg_basebackup.c
+++ src/bin/pg_basebackup/pg_basebackup.c
@@ -33,8 +33,24 @@
 #include "streamutil.h"
 
 
+#define atooid(x)  ((Oid) strtoul((x), NULL, 10))
+
+typedef struct TablespaceListCell
+{
+	struct TablespaceListCell *next;
+	char old_dir[MAXPGPATH + 1];
+	char new_dir[MAXPGPATH + 1];
+} TablespaceListCell;
+
+typedef struct TablespaceList
+{
+	TablespaceListCell *head;
+	TablespaceListCell *tail;
+} TablespaceList;
+
 /* Global options */
 static char *basedir = NULL;
+static TablespaceList tablespace_dirs = {NULL, NULL};
 static char *xlog_dir = "";
 static char	format = 'p';		/* p(lain)/t(ar) */
 static char *label = "pg_basebackup base backup";
@@ -86,6 +102,54 @@ static void BaseBackup(void);
 static bool reached_end_position(XLogRecPtr segendpos, uint32 timeline,
 					 bool segment_finished);
 
+static const char *get_tablespace_dir(const char *dir);
+static void update_tablespace_symlink(Oid oid, const char *old_dir);
+static bool tablespace_dirs_append(char *arg);
+
+/*
+ * Split tablespace argument into old_dir and new_dir, this accounts for
+ * directory name containing a colon.
+ */
+static bool
+tablespace_list_append(char *arg)
+{
+	TablespaceListCell *cell = (TablespaceListCell *) pg_malloc0(sizeof(TablespaceListCell));
+	char		*dst = cell->old_dir;
+	const char	*dst_head = dst;
+	const char	*arg_head = arg;
+
+	cell->next = NULL;
+
+	for (; *arg; arg++)
+	{
+		/* Check for overflow */
+		if (dst - dst_head >= MAXPGPATH)
+			return false;
+
+		/* Split on colon not trailing a slash */
+		if (*arg == '\\' && *(arg + 1) == ':')
+			;
+		else if (*arg != ':' || (arg != arg_head && *(arg - 1) == '\\'))
+			*(dst++) = *arg;
+		else if (!*(cell->old_dir) || *(cell->new_dir) || *(arg + 1) != '/')
+			return false;
+		else
+			dst_head = dst = cell->new_dir;
+	}
+
+	if (!(*(cell->old_dir) && *(cell->new_dir)))
+		return false;
+
+	if (tablespace_dirs.tail)
+		tablespace_dirs.tail->next = cell;
+	else
+		tablespace_dirs.head = cell;
+	tablespace_dirs.tail = cell;
+
+	return true;
+}
+
+
 #ifdef HAVE_LIBZ
 static const char *
 get_gz_error(gzFile gzf)
@@ -110,6 +174,8 @@ usage(void)
 	printf(_("  %s [OPTION]...\n"), progname);
 	printf(_("\nOptions controlling the output:\n"));
 	printf(_("  -D, --pgdata=DIRECTORY receive base backup into directory\n"));
+	printf(_("  -T, --tablespace=OLDDIR:NEWDIR\n"
+			 "                         relocate tablespace olddir to newdir\n"));
 	printf(_("  -F, --format=p|t       output format (plain (default), tar)\n"));
 	printf(_("  -R, --write-recovery-conf\n"
 			 "                         write recovery.conf after backup\n"));
@@ -861,14 +927,56 @@ ReceiveTarFile(PGconn *conn, PGresult *res, int rownum)
 }
 
 /*
+ * Retrieve tablespace path, either relocated or original depending on
+ * whether -T old_dir:new_dir was passed or not.
+ */
+static const char *
+get_tablespace_dir(const char *dir)
+{
+	TablespaceListCell *cell;
+
+	for (cell = tablespace_dirs.head; cell; cell = cell->next)
+		if (strcmp(dir, cell->old_dir) == 0)
+			return cell->new_dir;
+
+	return dir;
+}
+
+/*
+ * Update symlinks to reflect relocated tablespace, only applied if
+ * tablespace isn't in its original location.
+ */
+static void
+update_tablespace_symlink(Oid oid, const char *old_dir)
+{
+	const char *new_dir = get_tablespace_dir(old_dir);
+	if (strcmp(old_dir, new_dir) != 0)
+	{
+		char linkloc[MAXPGPATH];
+		snprintf(linkloc, sizeof(linkloc), "%s/pg_tblspc/%d", basedir, oid);
+		if (unlink(linkloc) < 0 && errno != ENOENT)
+		{
+			fprintf(stderr, _("%s: unable to remove \"%s\": %s"),
+					progname, linkloc, strerror(errno));
+			disconnect_and_exit(1);
+		}
+		if (symlink(new_dir, linkloc) < 0)
+		{
+			fprintf(stderr, _("%s: unable to create symlink \"%s\": %s"),
+					progname, linkloc, strerror(errno));
+			disconnect_and_exit(1);
+		}
+	}
+}
+
+/*
  * Receive a tar format stream from the connection to the server, and unpack
  * the contents of it into a directory. Only files, directories and
  * symlinks are supported, no other kinds of special files.
  *
  * If the data is for the main data directory, it will be restored in the
  * specified directory. If it's for another tablespace, it will be restored
- * in the original directory, since relocation of tablespaces is not
- * supported.
+ * in the original directory, if tablespace relocation is not enabled.
  */
 static void
 ReceiveAndUnpackTarFile(PGconn *conn, PGresult *res, int rownum)
@@ -884,7 +992,7 @@ ReceiveAndUnpackTarFile(PGconn *conn, PGresult *res, int rownum)
 	if (basetablespace)
 		strcpy(current_path, basedir);
 	else
-		strcpy(current_path, PQgetvalue(res, rownum, 1));
+		strcpy(current_path, get_tablespace_dir(PQgetvalue(res, rownum, 1)));
 
 	/*
 	 * Get the COPY data
@@ -1465,7 +1573,10 @@ BaseBackup(void)
 		 * we do anything anyway.
 		 */
 		if (format == 'p' && !PQgetisnull(res, i, 1))
-			verify_dir_is_empty_or_create(PQgetvalue(res, i, 1));
+		{
+			char *path = (char *) get_tablespace_dir(PQgetvalue(res, i, 1));
+			verify_dir_is_empty_or_create(path);
+		}
 	}
 
 	/*
@@ -1507,6 +1618,22 @@ BaseBackup(void)
 		progress_report(PQntuples(res), NULL);
 		fprintf(stderr, "\n");	/* Need to move to next line */
 	}
+
+	if (format == 'p' && tablespace_dirs.head != NULL)
+	{
+#ifdef HAVE_SYMLINK
+		for (i = 0; i < PQntuples(res); i++)
+		{
+			Oid tblspc_oid = atooid(PQgetvalue(res, i, 0));
+			if (tblspc_oid)
+				update_tablespace_symlink(tblspc_oid, PQgetvalue(res, i, 1));
+		}
+#else
+		fprintf(stderr, _("%s: not updating pg_tblspc with new tablespace relocation\n"),
+				progname);
+#endif
+	}
+
 	PQclear(res);
 
 	/*
@@ -1655,6 +1782,7 @@ main(int argc, char **argv)
 		{"help", no_argument, NULL, '?'},
 		{"version", no_argument, NULL, 'V'},
 		{"pgdata", required_argument, NULL, 'D'},
+		{"tablespace", required_argument, NULL, 'T'},
 		{"format", required_argument, NULL, 'F'},
 		{"checkpoint", required_argument, NULL, 'c'},
 		{"write-recovery-conf", no_argument, NULL, 'R'},
@@ -1697,7 +1825,7 @@ main(int argc, char **argv)
 		}
 	}
 
-	while ((c = getopt_long(argc, argv, "D:F:RxX:l:zZ:d:c:h:p:U:s:wWvP",
+	while ((c = getopt_long(argc, argv, "D:T:F:RxX:l:zZ:d:c:h:p:U:s:wWvP",
 							long_options, &option_index)) != -1)
 	{
 		switch (c)
@@ -1705,6 +1833,15 @@ main(int argc, char **argv)
 			case 'D':
 				basedir = pg_strdup(optarg);
 				break;
+			case 'T':
+				if (!tablespace_list_append(optarg))
+				{
+					fprintf(stderr,
+							_("%s: invalid tablespace format \"%s\", must be \"old_dir:/absolute-path\"\n"),
+							progname, optarg);
+					exit(1);
+				}
+				break;
 			case 'F':
 				if (strcmp(optarg, "p") == 0 || strcmp(optarg, "plain") == 0)
 					format = 'p';

commit 5bc533663dcad382ec65bef4a599a17272dfdd0d
Author: Steeve Lennmark <steevel@handeldsbanken.se>
Date:   Thu Jan 9 20:45:26 2014 +0000

    Add support for relocating tablespaces
    
    This is done by mapping old and new tablespace location using the format
    old_dir:new_dir. This also accounts for directory names containing
    colons.

diff --git doc/src/sgml/ref/pg_basebackup.sgml doc/src/sgml/ref/pg_basebackup.sgml
index c379df5..b345154 100644
--- doc/src/sgml/ref/pg_basebackup.sgml
+++ doc/src/sgml/ref/pg_basebackup.sgml
@@ -138,6 +138,19 @@ PostgreSQL documentation
      </varlistentry>
 
      <varlistentry>
+      <term><option>-T <replaceable class="parameter">olddir:newdir</replaceable></option></term>
+      <term><option>--tablespace=<replaceable class="parameter">olddir:newdir</replaceable></option></term>
+      <listitem>
+       <para>
+        Relocates the tablespace in directory <replaceable>olddir</replaceable>
+        to <replaceable>newdir</replaceable>. <replaceable>newdir</replaceable>
+        has to be an absolute path. This options can be specified multiple times
+        for multiple tablespaces.
+       </para>
+      </listitem>
+     </varlistentry>
+
+     <varlistentry>
       <term><option>-F <replaceable class="parameter">format</replaceable></option></term>
       <term><option>--format=<replaceable class="parameter">format</replaceable></option></term>
       <listitem>
@@ -530,7 +543,7 @@ PostgreSQL documentation
   <para>
    The way <productname>PostgreSQL</productname> manages tablespaces, the path
    for all additional tablespaces must be identical whenever a backup is
-   restored. The main data directory, however, is relocatable to any location.
+   restored, if <replaceable>--tablespace</replaceable> isn't specified.
   </para>
 
   <para>
@@ -570,6 +583,14 @@ PostgreSQL documentation
    (This command will fail if there are multiple tablespaces in the
    database.)
   </para>
+
+  <para>
+   To create a backup of a two-tablespace local database where tablespace
+   <literal>/opt/ts</literal> is relocated to <literal>./backup/archive</literal>
+<screen>
+<prompt>$</prompt> <userinput>pg_basebackup -D $(pwd)/backup/data -T /opt/ts:$(pwd)/backup/archive</userinput>
+</screen>
+  </para>
  </refsect1>
 
  <refsect1>
diff --git src/bin/pg_basebackup/pg_basebackup.c src/bin/pg_basebackup/pg_basebackup.c
index 9d13d57..cbc9f87 100644
--- src/bin/pg_basebackup/pg_basebackup.c
+++ src/bin/pg_basebackup/pg_basebackup.c
@@ -33,8 +33,24 @@
 #include "streamutil.h"
 
 
+#define atooid(x)  ((Oid) strtoul((x), NULL, 10))
+
+typedef struct TablespaceListCell
+{
+	struct TablespaceListCell *next;
+	char old_dir[MAXPGPATH];
+	char new_dir[MAXPGPATH];
+} TablespaceListCell;
+
+typedef struct TablespaceList
+{
+	TablespaceListCell *head;
+	TablespaceListCell *tail;
+} TablespaceList;
+
 /* Global options */
 static char *basedir = NULL;
+static TablespaceList tablespace_dirs = {NULL, NULL};
 static char *xlog_dir = "";
 static char	format = 'p';		/* p(lain)/t(ar) */
 static char *label = "pg_basebackup base backup";
@@ -86,6 +102,54 @@ static void BaseBackup(void);
 static bool reached_end_position(XLogRecPtr segendpos, uint32 timeline,
 					 bool segment_finished);
 
+static const char *get_tablespace_dir(const char *dir);
+static void update_tablespace_symlink(Oid oid, const char *old_dir);
+static bool tablespace_list_append(char *arg);
+
+/*
+ * Split tablespace argument into old_dir and new_dir, this accounts for
+ * directory name containing a colon.
+ */
+static bool
+tablespace_list_append(char *arg)
+{
+	TablespaceListCell *cell = (TablespaceListCell *) pg_malloc0(sizeof(TablespaceListCell));
+	char		*dst = cell->old_dir;
+	const char	*dst_head = dst;
+	const char	*arg_head = arg;
+
+	cell->next = NULL;
+
+	for (; *arg; arg++)
+	{
+		/* Check for overflow */
+		if (dst - dst_head >= MAXPGPATH)
+			return false;
+
+		/* Split on colon not trailing a slash */
+		if (*arg == '\\' && *(arg + 1) == ':')
+			;
+		else if (*arg != ':' || (arg != arg_head && *(arg - 1) == '\\'))
+			*dst++ = *arg;
+		else if (!*cell->old_dir || *cell->new_dir || *(arg + 1) != '/')
+			return false;
+		else
+			dst_head = dst = cell->new_dir;
+	}
+
+	if (!(*cell->old_dir && *cell->new_dir))
+		return false;
+
+	if (tablespace_dirs.tail)
+		tablespace_dirs.tail->next = cell;
+	else
+		tablespace_dirs.head = cell;
+	tablespace_dirs.tail = cell;
+
+	return true;
+}
+
+
 #ifdef HAVE_LIBZ
 static const char *
 get_gz_error(gzFile gzf)
@@ -110,6 +174,8 @@ usage(void)
 	printf(_("  %s [OPTION]...\n"), progname);
 	printf(_("\nOptions controlling the output:\n"));
 	printf(_("  -D, --pgdata=DIRECTORY receive base backup into directory\n"));
+	printf(_("  -T, --tablespace=OLDDIR:NEWDIR\n"
+			 "                         relocate tablespace olddir to newdir\n"));
 	printf(_("  -F, --format=p|t       output format (plain (default), tar)\n"));
 	printf(_("  -R, --write-recovery-conf\n"
 			 "                         write recovery.conf after backup\n"));
@@ -861,14 +927,56 @@ ReceiveTarFile(PGconn *conn, PGresult *res, int rownum)
 }
 
 /*
+ * Retrieve tablespace path, either relocated or original depending on
+ * whether -T old_dir:new_dir was passed or not.
+ */
+static const char *
+get_tablespace_dir(const char *dir)
+{
+	TablespaceListCell *cell;
+
+	for (cell = tablespace_dirs.head; cell; cell = cell->next)
+		if (strcmp(dir, cell->old_dir) == 0)
+			return cell->new_dir;
+
+	return dir;
+}
+
+/*
+ * Update symlinks to reflect relocated tablespace, only applied if
+ * tablespace isn't in its original location.
+ */
+static void
+update_tablespace_symlink(Oid oid, const char *old_dir)
+{
+	const char *new_dir = get_tablespace_dir(old_dir);
+	if (strcmp(old_dir, new_dir) != 0)
+	{
+		char linkloc[MAXPGPATH];
+		snprintf(linkloc, sizeof(linkloc), "%s/pg_tblspc/%d", basedir, oid);
+		if (unlink(linkloc) < 0 && errno != ENOENT)
+		{
+			fprintf(stderr, _("%s: unable to remove \"%s\": %s"),
+					progname, linkloc, strerror(errno));
+			disconnect_and_exit(1);
+		}
+		if (symlink(new_dir, linkloc) < 0)
+		{
+			fprintf(stderr, _("%s: unable to create symlink \"%s\": %s"),
+					progname, linkloc, strerror(errno));
+			disconnect_and_exit(1);
+		}
+	}
+}
+
+/*
  * Receive a tar format stream from the connection to the server, and unpack
  * the contents of it into a directory. Only files, directories and
  * symlinks are supported, no other kinds of special files.
  *
  * If the data is for the main data directory, it will be restored in the
  * specified directory. If it's for another tablespace, it will be restored
- * in the original directory, since relocation of tablespaces is not
- * supported.
+ * in the original directory, if tablespace relocation is not enabled.
  */
 static void
 ReceiveAndUnpackTarFile(PGconn *conn, PGresult *res, int rownum)
@@ -884,7 +992,7 @@ ReceiveAndUnpackTarFile(PGconn *conn, PGresult *res, int rownum)
 	if (basetablespace)
 		strcpy(current_path, basedir);
 	else
-		strcpy(current_path, PQgetvalue(res, rownum, 1));
+		strcpy(current_path, get_tablespace_dir(PQgetvalue(res, rownum, 1)));
 
 	/*
 	 * Get the COPY data
@@ -1465,7 +1573,10 @@ BaseBackup(void)
 		 * we do anything anyway.
 		 */
 		if (format == 'p' && !PQgetisnull(res, i, 1))
-			verify_dir_is_empty_or_create(PQgetvalue(res, i, 1));
+		{
+			char *path = (char *) get_tablespace_dir(PQgetvalue(res, i, 1));
+			verify_dir_is_empty_or_create(path);
+		}
 	}
 
 	/*
@@ -1507,6 +1618,22 @@ BaseBackup(void)
 		progress_report(PQntuples(res), NULL);
 		fprintf(stderr, "\n");	/* Need to move to next line */
 	}
+
+	if (format == 'p' && tablespace_dirs.head != NULL)
+	{
+#ifdef HAVE_SYMLINK
+		for (i = 0; i < PQntuples(res); i++)
+		{
+			Oid tblspc_oid = atooid(PQgetvalue(res, i, 0));
+			if (tblspc_oid)
+				update_tablespace_symlink(tblspc_oid, PQgetvalue(res, i, 1));
+		}
+#else
+		fprintf(stderr, _("%s: not updating pg_tblspc with new tablespace relocation\n"),
+				progname);
+#endif
+	}
+
 	PQclear(res);
 
 	/*
@@ -1655,6 +1782,7 @@ main(int argc, char **argv)
 		{"help", no_argument, NULL, '?'},
 		{"version", no_argument, NULL, 'V'},
 		{"pgdata", required_argument, NULL, 'D'},
+		{"tablespace", required_argument, NULL, 'T'},
 		{"format", required_argument, NULL, 'F'},
 		{"checkpoint", required_argument, NULL, 'c'},
 		{"write-recovery-conf", no_argument, NULL, 'R'},
@@ -1697,7 +1825,7 @@ main(int argc, char **argv)
 		}
 	}
 
-	while ((c = getopt_long(argc, argv, "D:F:RxX:l:zZ:d:c:h:p:U:s:wWvP",
+	while ((c = getopt_long(argc, argv, "D:T:F:RxX:l:zZ:d:c:h:p:U:s:wWvP",
 							long_options, &option_index)) != -1)
 	{
 		switch (c)
@@ -1705,6 +1833,15 @@ main(int argc, char **argv)
 			case 'D':
 				basedir = pg_strdup(optarg);
 				break;
+			case 'T':
+				if (!tablespace_list_append(optarg))
+				{
+					fprintf(stderr,
+							_("%s: invalid tablespace format \"%s\", must be \"old_dir:/absolute-path\"\n"),
+							progname, optarg);
+					exit(1);
+				}
+				break;
 			case 'F':
 				if (strcmp(optarg, "p") == 0 || strcmp(optarg, "plain") == 0)
 					format = 'p';

commit c6b714c89f20131ffa642aa019ff1a01b9361672
Author: Steeve Lennmark <steeve@blocket.se>
Date:   Thu Jan 16 17:46:16 2014 +0100

    Add support for relocating tablespaces
    
    This is done by mapping old and new tablespace location using the format
    old_dir:new_dir. This also accounts for directory names containing
    colons.

diff --git doc/src/sgml/ref/pg_basebackup.sgml doc/src/sgml/ref/pg_basebackup.sgml
index c379df5..fb96bd3 100644
--- doc/src/sgml/ref/pg_basebackup.sgml
+++ doc/src/sgml/ref/pg_basebackup.sgml
@@ -203,6 +203,19 @@ PostgreSQL documentation
      </varlistentry>
 
      <varlistentry>
+      <term><option>-T <replaceable class="parameter">olddir:newdir</replaceable></option></term>
+      <term><option>--tablespace=<replaceable class="parameter">olddir:newdir</replaceable></option></term>
+      <listitem>
+       <para>
+        Relocates the tablespace in directory <replaceable>olddir</replaceable>
+        to <replaceable>newdir</replaceable>. <replaceable>newdir</replaceable>
+        has to be an absolute path. This options can be specified multiple times
+        for multiple tablespaces.
+       </para>
+      </listitem>
+     </varlistentry>
+
+     <varlistentry>
       <term><option>--xlogdir=<replaceable class="parameter">xlogdir</replaceable></option></term>
       <listitem>
        <para>
@@ -530,7 +543,7 @@ PostgreSQL documentation
   <para>
    The way <productname>PostgreSQL</productname> manages tablespaces, the path
    for all additional tablespaces must be identical whenever a backup is
-   restored. The main data directory, however, is relocatable to any location.
+   restored, if <replaceable>--tablespace</replaceable> isn't specified.
   </para>
 
   <para>
@@ -570,6 +583,14 @@ PostgreSQL documentation
    (This command will fail if there are multiple tablespaces in the
    database.)
   </para>
+
+  <para>
+   To create a backup of a two-tablespace local database where tablespace
+   <literal>/opt/ts</literal> is relocated to <literal>./backup/archive</literal>
+<screen>
+<prompt>$</prompt> <userinput>pg_basebackup -D $(pwd)/backup/data -T /opt/ts:$(pwd)/backup/archive</userinput>
+</screen>
+  </para>
  </refsect1>
 
  <refsect1>
diff --git src/bin/pg_basebackup/pg_basebackup.c src/bin/pg_basebackup/pg_basebackup.c
index 9d13d57..a92fa7b 100644
--- src/bin/pg_basebackup/pg_basebackup.c
+++ src/bin/pg_basebackup/pg_basebackup.c
@@ -33,8 +33,24 @@
 #include "streamutil.h"
 
 
+#define atooid(x)  ((Oid) strtoul((x), NULL, 10))
+
+typedef struct TablespaceListCell
+{
+	struct TablespaceListCell *next;
+	char old_dir[MAXPGPATH];
+	char new_dir[MAXPGPATH];
+} TablespaceListCell;
+
+typedef struct TablespaceList
+{
+	TablespaceListCell *head;
+	TablespaceListCell *tail;
+} TablespaceList;
+
 /* Global options */
 static char *basedir = NULL;
+static TablespaceList tablespace_dirs = {NULL, NULL};
 static char *xlog_dir = "";
 static char	format = 'p';		/* p(lain)/t(ar) */
 static char *label = "pg_basebackup base backup";
@@ -86,6 +102,54 @@ static void BaseBackup(void);
 static bool reached_end_position(XLogRecPtr segendpos, uint32 timeline,
 					 bool segment_finished);
 
+static const char *get_tablespace_dir(const char *dir);
+static void update_tablespace_symlink(Oid oid, const char *old_dir);
+static bool tablespace_list_append(char *arg);
+
+/*
+ * Split tablespace argument into old_dir and new_dir, this accounts for
+ * directory name containing a colon.
+ */
+static bool
+tablespace_list_append(char *arg)
+{
+	TablespaceListCell *cell = (TablespaceListCell *) pg_malloc0(sizeof(TablespaceListCell));
+	char		*dst = cell->old_dir;
+	const char	*dst_head = dst;
+	const char	*arg_head = arg;
+
+	cell->next = NULL;
+
+	for (; *arg; arg++)
+	{
+		/* Check for overflow */
+		if (dst - dst_head >= MAXPGPATH)
+			return false;
+
+		/* Split on colon not trailing a slash */
+		if (*arg == '\\' && *(arg + 1) == ':')
+			;
+		else if (*arg != ':' || (arg != arg_head && *(arg - 1) == '\\'))
+			*dst++ = *arg;
+		else if (!*cell->old_dir || *cell->new_dir || *(arg + 1) != '/')
+			return false;
+		else
+			dst_head = dst = cell->new_dir;
+	}
+
+	if (!(*cell->old_dir && *cell->new_dir))
+		return false;
+
+	if (tablespace_dirs.tail)
+		tablespace_dirs.tail->next = cell;
+	else
+		tablespace_dirs.head = cell;
+	tablespace_dirs.tail = cell;
+
+	return true;
+}
+
+
 #ifdef HAVE_LIBZ
 static const char *
 get_gz_error(gzFile gzf)
@@ -113,6 +177,8 @@ usage(void)
 	printf(_("  -F, --format=p|t       output format (plain (default), tar)\n"));
 	printf(_("  -R, --write-recovery-conf\n"
 			 "                         write recovery.conf after backup\n"));
+	printf(_("  -T, --tablespace=OLDDIR:NEWDIR\n"
+			 "                         relocate tablespace olddir to newdir\n"));
 	printf(_("  -x, --xlog             include required WAL files in backup (fetch mode)\n"));
 	printf(_("  -X, --xlog-method=fetch|stream\n"
 			 "                         include required WAL files with specified method\n"));
@@ -861,14 +927,56 @@ ReceiveTarFile(PGconn *conn, PGresult *res, int rownum)
 }
 
 /*
+ * Retrieve tablespace path, either relocated or original depending on
+ * whether -T old_dir:new_dir was passed or not.
+ */
+static const char *
+get_tablespace_dir(const char *dir)
+{
+	TablespaceListCell *cell;
+
+	for (cell = tablespace_dirs.head; cell; cell = cell->next)
+		if (strcmp(dir, cell->old_dir) == 0)
+			return cell->new_dir;
+
+	return dir;
+}
+
+/*
+ * Update symlinks to reflect relocated tablespace, only applied if
+ * tablespace isn't in its original location.
+ */
+static void
+update_tablespace_symlink(Oid oid, const char *old_dir)
+{
+	const char *new_dir = get_tablespace_dir(old_dir);
+	if (strcmp(old_dir, new_dir) != 0)
+	{
+		char linkloc[MAXPGPATH];
+		snprintf(linkloc, sizeof(linkloc), "%s/pg_tblspc/%d", basedir, oid);
+		if (unlink(linkloc) < 0 && errno != ENOENT)
+		{
+			fprintf(stderr, _("%s: unable to remove \"%s\": %s"),
+					progname, linkloc, strerror(errno));
+			disconnect_and_exit(1);
+		}
+		if (symlink(new_dir, linkloc) < 0)
+		{
+			fprintf(stderr, _("%s: unable to create symlink \"%s\": %s"),
+					progname, linkloc, strerror(errno));
+			disconnect_and_exit(1);
+		}
+	}
+}
+
+/*
  * Receive a tar format stream from the connection to the server, and unpack
  * the contents of it into a directory. Only files, directories and
  * symlinks are supported, no other kinds of special files.
  *
  * If the data is for the main data directory, it will be restored in the
  * specified directory. If it's for another tablespace, it will be restored
- * in the original directory, since relocation of tablespaces is not
- * supported.
+ * in the original directory, if tablespace relocation is not enabled.
  */
 static void
 ReceiveAndUnpackTarFile(PGconn *conn, PGresult *res, int rownum)
@@ -884,7 +992,7 @@ ReceiveAndUnpackTarFile(PGconn *conn, PGresult *res, int rownum)
 	if (basetablespace)
 		strcpy(current_path, basedir);
 	else
-		strcpy(current_path, PQgetvalue(res, rownum, 1));
+		strcpy(current_path, get_tablespace_dir(PQgetvalue(res, rownum, 1)));
 
 	/*
 	 * Get the COPY data
@@ -1465,7 +1573,10 @@ BaseBackup(void)
 		 * we do anything anyway.
 		 */
 		if (format == 'p' && !PQgetisnull(res, i, 1))
-			verify_dir_is_empty_or_create(PQgetvalue(res, i, 1));
+		{
+			char *path = (char *) get_tablespace_dir(PQgetvalue(res, i, 1));
+			verify_dir_is_empty_or_create(path);
+		}
 	}
 
 	/*
@@ -1507,6 +1618,22 @@ BaseBackup(void)
 		progress_report(PQntuples(res), NULL);
 		fprintf(stderr, "\n");	/* Need to move to next line */
 	}
+
+	if (format == 'p' && tablespace_dirs.head != NULL)
+	{
+#ifdef HAVE_SYMLINK
+		for (i = 0; i < PQntuples(res); i++)
+		{
+			Oid tblspc_oid = atooid(PQgetvalue(res, i, 0));
+			if (tblspc_oid)
+				update_tablespace_symlink(tblspc_oid, PQgetvalue(res, i, 1));
+		}
+#else
+		fprintf(stderr, _("%s: not updating pg_tblspc with new tablespace relocation\n"),
+				progname);
+#endif
+	}
+
 	PQclear(res);
 
 	/*
@@ -1655,6 +1782,7 @@ main(int argc, char **argv)
 		{"help", no_argument, NULL, '?'},
 		{"version", no_argument, NULL, 'V'},
 		{"pgdata", required_argument, NULL, 'D'},
+		{"tablespace", required_argument, NULL, 'T'},
 		{"format", required_argument, NULL, 'F'},
 		{"checkpoint", required_argument, NULL, 'c'},
 		{"write-recovery-conf", no_argument, NULL, 'R'},
@@ -1697,7 +1825,7 @@ main(int argc, char **argv)
 		}
 	}
 
-	while ((c = getopt_long(argc, argv, "D:F:RxX:l:zZ:d:c:h:p:U:s:wWvP",
+	while ((c = getopt_long(argc, argv, "D:T:F:RxX:l:zZ:d:c:h:p:U:s:wWvP",
 							long_options, &option_index)) != -1)
 	{
 		switch (c)
@@ -1705,6 +1833,15 @@ main(int argc, char **argv)
 			case 'D':
 				basedir = pg_strdup(optarg);
 				break;
+			case 'T':
+				if (!tablespace_list_append(optarg))
+				{
+					fprintf(stderr,
+							_("%s: invalid tablespace format \"%s\", must be \"old_dir:/absolute-path\"\n"),
+							progname, optarg);
+					exit(1);
+				}
+				break;
 			case 'F':
 				if (strcmp(optarg, "p") == 0 || strcmp(optarg, "plain") == 0)
 					format = 'p';

commit fb04753d6554f9450106c9b00047dcd70bb7d068
Author: Steeve Lennmark <steevel@handeldsbanken.se>
Date:   Thu Jan 9 20:45:26 2014 +0000

    Add support for relocating tablespaces
    
    Relocate tablespace(s) by specifying one or more -T olddir=newdir. This
    supports partial matching path matching which makes it possible to
    relocate multiple tablespaces with just one parameter.
    
    Examples:
    -T /tablespaces=backup/tablespaces
    -T /tablespaces/index=backup/tablespaces/index

diff --git a/doc/src/sgml/ref/pg_basebackup.sgml b/doc/src/sgml/ref/pg_basebackup.sgml
index c379df5..0555531 100644
--- a/doc/src/sgml/ref/pg_basebackup.sgml
+++ b/doc/src/sgml/ref/pg_basebackup.sgml
@@ -138,6 +138,18 @@ PostgreSQL documentation
      </varlistentry>
 
      <varlistentry>
+      <term><option>-T <replaceable class="parameter">olddir=newdir</replaceable></option></term>
+      <term><option>--tablespace-mapping=<replaceable class="parameter">olddir=newdir</replaceable></option></term>
+      <listitem>
+       <para>
+        Relocates the tablespace(s) in directory <replaceable>olddir</replaceable>
+        to <replaceable>newdir</replaceable>. This options can be specified multiple times
+        for multiple tablespaces.
+       </para>
+      </listitem>
+     </varlistentry>
+
+     <varlistentry>
       <term><option>-F <replaceable class="parameter">format</replaceable></option></term>
       <term><option>--format=<replaceable class="parameter">format</replaceable></option></term>
       <listitem>
@@ -530,7 +542,7 @@ PostgreSQL documentation
   <para>
    The way <productname>PostgreSQL</productname> manages tablespaces, the path
    for all additional tablespaces must be identical whenever a backup is
-   restored. The main data directory, however, is relocatable to any location.
+   restored, if <replaceable>--tablespace-mapping</replaceable> isn't specified.
   </para>
 
   <para>
@@ -570,6 +582,14 @@ PostgreSQL documentation
    (This command will fail if there are multiple tablespaces in the
    database.)
   </para>
+
+  <para>
+   To create a backup of a two-tablespace local database where tablespace
+   <literal>/opt/ts</literal> is relocated to <literal>./backup/archive</literal>
+<screen>
+<prompt>$</prompt> <userinput>pg_basebackup -D $(pwd)/backup/data -T /opt/ts:$(pwd)/backup/archive</userinput>
+</screen>
+  </para>
  </refsect1>
 
  <refsect1>
diff --git a/src/bin/pg_basebackup/pg_basebackup.c b/src/bin/pg_basebackup/pg_basebackup.c
index 9d13d57..8f852b2 100644
--- a/src/bin/pg_basebackup/pg_basebackup.c
+++ b/src/bin/pg_basebackup/pg_basebackup.c
@@ -33,8 +33,27 @@
 #include "streamutil.h"
 
 
+#define atooid(x)  ((Oid) strtoul((x), NULL, 10))
+
+/* Char used to separate olddir and newdir for tablespace */
+static const char TBLSPC_SEP = '=';
+
+typedef struct TablespaceListCell
+{
+	struct TablespaceListCell *next;
+	char old_dir[MAXPGPATH];
+	char new_dir[MAXPGPATH];
+} TablespaceListCell;
+
+typedef struct TablespaceList
+{
+	TablespaceListCell *head;
+	TablespaceListCell *tail;
+} TablespaceList;
+
 /* Global options */
 static char *basedir = NULL;
+static TablespaceList tablespace_dirs = {NULL, NULL};
 static char *xlog_dir = "";
 static char	format = 'p';		/* p(lain)/t(ar) */
 static char *label = "pg_basebackup base backup";
@@ -86,6 +105,74 @@ static void BaseBackup(void);
 static bool reached_end_position(XLogRecPtr segendpos, uint32 timeline,
 					 bool segment_finished);
 
+static const char *get_tablespace_dir(const char *dir);
+static void update_tablespace_symlink(Oid oid, const char *old_dir);
+static bool tablespace_list_append(char *arg);
+
+/*
+ * Split tablespace argument into old_dir and new_dir, this accounts for
+ * directory name containing a colon.
+ */
+static bool
+tablespace_list_append(char *arg)
+{
+	TablespaceListCell *cell = (TablespaceListCell *) pg_malloc0(sizeof(TablespaceListCell));
+	char		*dst = cell->old_dir;
+	const char	*dst_head = dst;
+	const char	*arg_head = arg;
+
+	cell->next = NULL;
+
+	for (; *arg; arg++)
+	{
+		/* Check for overflow */
+		if (dst - dst_head >= MAXPGPATH)
+		{
+			fprintf(stderr, _("%s: directory name too long (max %d bytes)\n"),
+					progname, MAXPGPATH);
+			exit(1);
+		}
+
+		/* Split on colon not trailing a slash */
+		if (*arg == '\\' && *(arg + 1) == TBLSPC_SEP)
+			;
+		else if (*arg != TBLSPC_SEP || (arg != arg_head && *(arg - 1) == '\\'))
+			*dst++ = *arg;
+		else if (!*cell->old_dir || *cell->new_dir)
+			return false;
+		/* Found directory separator, switch to new directory */
+		else
+		{
+			dst_head = dst = cell->new_dir;
+
+			/* Add cwd if this is a relative path */
+			if (*(arg + 1) != '/')
+			{
+				if (!getcwd(dst, MAXPGPATH))
+				{
+					fprintf(stderr, _("%s: could not identify current directory: %s\n"),
+							progname, strerror(errno));
+					exit(1);
+				}
+				dst += strlen(dst);
+				*dst++ = '/';
+			}
+		}
+	}
+
+	if (!(*cell->old_dir && *cell->new_dir))
+		return false;
+
+	if (tablespace_dirs.tail)
+		tablespace_dirs.tail->next = cell;
+	else
+		tablespace_dirs.head = cell;
+	tablespace_dirs.tail = cell;
+
+	return true;
+}
+
+
 #ifdef HAVE_LIBZ
 static const char *
 get_gz_error(gzFile gzf)
@@ -113,6 +200,8 @@ usage(void)
 	printf(_("  -F, --format=p|t       output format (plain (default), tar)\n"));
 	printf(_("  -R, --write-recovery-conf\n"
 			 "                         write recovery.conf after backup\n"));
+	printf(_("  -T, --tablespace-mapping=OLDDIR=NEWDIR\n"
+			 "                         relocate tablespace matching olddir to newdir\n"));
 	printf(_("  -x, --xlog             include required WAL files in backup (fetch mode)\n"));
 	printf(_("  -X, --xlog-method=fetch|stream\n"
 			 "                         include required WAL files with specified method\n"));
@@ -861,14 +950,59 @@ ReceiveTarFile(PGconn *conn, PGresult *res, int rownum)
 }
 
 /*
+ * Retrieve tablespace path, either relocated or original depending on
+ * whether -T old_dir=new_dir was passed or not.
+ */
+static const char *
+get_tablespace_dir(const char *dir)
+{
+	TablespaceListCell *cell;
+
+	for (cell = tablespace_dirs.head; cell; cell = cell->next)
+		if (strcmp(dir, cell->old_dir) == 0)
+			return cell->new_dir;
+		else if (strstr(dir, cell->old_dir) != NULL)
+			return psprintf("%s/%s",
+							cell->new_dir,
+							dir + strlen(cell->old_dir) + 1);
+
+	return dir;
+}
+
+/*
+ * Update symlinks to reflect relocated tablespace, only applied if
+ * tablespace isn't in its original location.
+ */
+static void
+update_tablespace_symlink(Oid oid, const char *old_dir)
+{
+	const char *new_dir = get_tablespace_dir(old_dir);
+	if (strcmp(old_dir, new_dir) != 0)
+	{
+		char *linkloc = psprintf("%s/pg_tblspc/%d", basedir, oid);
+		if (unlink(linkloc) < 0 && errno != ENOENT)
+		{
+			fprintf(stderr, _("%s: could not remove symbolic link \"%s\": %s"),
+					progname, linkloc, strerror(errno));
+			disconnect_and_exit(1);
+		}
+		if (symlink(new_dir, linkloc) < 0)
+		{
+			fprintf(stderr, _("%s: could not create symbolic link \"%s\": %s"),
+					progname, linkloc, strerror(errno));
+			disconnect_and_exit(1);
+		}
+	}
+}
+
+/*
  * Receive a tar format stream from the connection to the server, and unpack
  * the contents of it into a directory. Only files, directories and
  * symlinks are supported, no other kinds of special files.
  *
  * If the data is for the main data directory, it will be restored in the
  * specified directory. If it's for another tablespace, it will be restored
- * in the original directory, since relocation of tablespaces is not
- * supported.
+ * in the original directory, if tablespace relocation is not enabled.
  */
 static void
 ReceiveAndUnpackTarFile(PGconn *conn, PGresult *res, int rownum)
@@ -884,7 +1018,7 @@ ReceiveAndUnpackTarFile(PGconn *conn, PGresult *res, int rownum)
 	if (basetablespace)
 		strcpy(current_path, basedir);
 	else
-		strcpy(current_path, PQgetvalue(res, rownum, 1));
+		strcpy(current_path, get_tablespace_dir(PQgetvalue(res, rownum, 1)));
 
 	/*
 	 * Get the COPY data
@@ -1465,7 +1599,10 @@ BaseBackup(void)
 		 * we do anything anyway.
 		 */
 		if (format == 'p' && !PQgetisnull(res, i, 1))
-			verify_dir_is_empty_or_create(PQgetvalue(res, i, 1));
+		{
+			char *path = (char *) get_tablespace_dir(PQgetvalue(res, i, 1));
+			verify_dir_is_empty_or_create(path);
+		}
 	}
 
 	/*
@@ -1507,6 +1644,22 @@ BaseBackup(void)
 		progress_report(PQntuples(res), NULL);
 		fprintf(stderr, "\n");	/* Need to move to next line */
 	}
+
+	if (format == 'p' && tablespace_dirs.head != NULL)
+	{
+#ifdef HAVE_SYMLINK
+		for (i = 0; i < PQntuples(res); i++)
+		{
+			Oid tblspc_oid = atooid(PQgetvalue(res, i, 0));
+			if (tblspc_oid)
+				update_tablespace_symlink(tblspc_oid, PQgetvalue(res, i, 1));
+		}
+#else
+		fprintf(stderr, _("%s: tablespace relocation is not supported on this platform\n"),
+				progname);
+#endif
+	}
+
 	PQclear(res);
 
 	/*
@@ -1658,6 +1811,7 @@ main(int argc, char **argv)
 		{"format", required_argument, NULL, 'F'},
 		{"checkpoint", required_argument, NULL, 'c'},
 		{"write-recovery-conf", no_argument, NULL, 'R'},
+		{"tablespace-mapping", required_argument, NULL, 'T'},
 		{"xlog", no_argument, NULL, 'x'},
 		{"xlog-method", required_argument, NULL, 'X'},
 		{"gzip", no_argument, NULL, 'z'},
@@ -1697,7 +1851,7 @@ main(int argc, char **argv)
 		}
 	}
 
-	while ((c = getopt_long(argc, argv, "D:F:RxX:l:zZ:d:c:h:p:U:s:wWvP",
+	while ((c = getopt_long(argc, argv, "D:F:RT:xX:l:zZ:d:c:h:p:U:s:wWvP",
 							long_options, &option_index)) != -1)
 	{
 		switch (c)
@@ -1721,6 +1875,15 @@ main(int argc, char **argv)
 			case 'R':
 				writerecoveryconf = true;
 				break;
+			case 'T':
+				if (!tablespace_list_append(optarg))
+				{
+					fprintf(stderr,
+							_("%s: invalid tablespace mapping format \"%s\", must be \"olddir=newdir\"\n"),
+							progname, optarg);
+					exit(1);
+				}
+				break;
 			case 'x':
 				if (includewal)
 				{

>From cc189020d04ff2311c92108620e4fc74f80c01c9 Mon Sep 17 00:00:00 2001
From: Peter Eisentraut <peter_e@gmx.net>
Date: Sat, 15 Feb 2014 08:42:20 -0500
Subject: [PATCH] pg_basebackup: Add support for relocating tablespaces

Tablespaces can be relocated in plain backup mode by specifying one or
more -T olddir=newdir options.

From: Steeve Lennmark <steevel@handeldsbanken.se>
Reviewed-by: Peter Eisentraut <peter_e@gmx.net>
---
 doc/src/sgml/ref/pg_basebackup.sgml   |  46 +++++++++-
 src/bin/pg_basebackup/pg_basebackup.c | 166 +++++++++++++++++++++++++++++++++-
 2 files changed, 204 insertions(+), 8 deletions(-)

diff --git a/doc/src/sgml/ref/pg_basebackup.sgml b/doc/src/sgml/ref/pg_basebackup.sgml
index c379df5..ea22331 100644
--- a/doc/src/sgml/ref/pg_basebackup.sgml
+++ b/doc/src/sgml/ref/pg_basebackup.sgml
@@ -203,6 +203,33 @@ <title>Options</title>
      </varlistentry>
 
      <varlistentry>
+      <term><option>-T <replaceable class="parameter">olddir</replaceable>=<replaceable class="parameter">newdir</replaceable></option></term>
+      <term><option>--tablespace-mapping=<replaceable class="parameter">olddir</replaceable>=<replaceable class="parameter">newdir</replaceable></option></term>
+      <listitem>
+       <para>
+        Relocate the tablespace in directory <replaceable>olddir</replaceable>
+        to <replaceable>newdir</replaceable> during the backup.  To be
+        effective, <replaceable>olddir</replaceable> must exactly match the
+        path specification of the tablespace as it is currently defined.  (But
+        it is not an error if there is no tablespace
+        in <replaceable>olddir</replaceable> contained in the backup.)
+        Both <replaceable>olddir</replaceable>
+        and <replaceable>newdir</replaceable> must be absolute paths.  If a
+        path happens to contain a <literal>=</literal> sign, escape it with a
+        backslash.  This option can be specified multiple times for multiple
+        tablespaces.  See examples below.
+       </para>
+
+       <para>
+        If a tablespace is relocated in this way, the symbolic links inside
+        the main data directory are updated to point to the new location.  So
+        the new data directory is ready to be used for a new server instance
+        with all tablespaces in the updated locations.
+        </para>
+      </listitem>
+     </varlistentry>
+
+     <varlistentry>
       <term><option>--xlogdir=<replaceable class="parameter">xlogdir</replaceable></option></term>
       <listitem>
        <para>
@@ -528,9 +555,13 @@ <title>Notes</title>
   </para>
 
   <para>
-   The way <productname>PostgreSQL</productname> manages tablespaces, the path
-   for all additional tablespaces must be identical whenever a backup is
-   restored. The main data directory, however, is relocatable to any location.
+   Tablespaces will in plain format by default be backed up to the same path
+   they have on the server, unless the
+   option <replaceable>--tablespace-mapping</replaceable> is used.  Without
+   this option, running a plain format base backup on the same host as the
+   server will not work if tablespaces are in use, because the backup would
+   have to be written to the same directory locations as the original
+   tablespaces.
   </para>
 
   <para>
@@ -570,6 +601,15 @@ <title>Examples</title>
    (This command will fail if there are multiple tablespaces in the
    database.)
   </para>
+
+  <para>
+   To create a backup of a local database where the tablespace in
+   <filename>/opt/ts</filename> is relocated
+   to <filename>./backup/ts</filename>:
+<screen>
+<prompt>$</prompt> <userinput>pg_basebackup -D backup/data -T /opt/ts=$(pwd)/backup/ts</userinput>
+</screen>
+  </para>
  </refsect1>
 
  <refsect1>
diff --git a/src/bin/pg_basebackup/pg_basebackup.c b/src/bin/pg_basebackup/pg_basebackup.c
index b5682d6..b27678f 100644
--- a/src/bin/pg_basebackup/pg_basebackup.c
+++ b/src/bin/pg_basebackup/pg_basebackup.c
@@ -35,8 +35,24 @@
 #include "streamutil.h"
 
 
+#define atooid(x)  ((Oid) strtoul((x), NULL, 10))
+
+typedef struct TablespaceListCell
+{
+	struct TablespaceListCell *next;
+	char old_dir[MAXPGPATH];
+	char new_dir[MAXPGPATH];
+} TablespaceListCell;
+
+typedef struct TablespaceList
+{
+	TablespaceListCell *head;
+	TablespaceListCell *tail;
+} TablespaceList;
+
 /* Global options */
 static char *basedir = NULL;
+static TablespaceList tablespace_dirs = {NULL, NULL};
 static char *xlog_dir = "";
 static char	format = 'p';		/* p(lain)/t(ar) */
 static char *label = "pg_basebackup base backup";
@@ -90,6 +106,10 @@
 static bool reached_end_position(XLogRecPtr segendpos, uint32 timeline,
 					 bool segment_finished);
 
+static const char *get_tablespace_mapping(const char *dir);
+static void update_tablespace_symlink(Oid oid, const char *old_dir);
+static void tablespace_list_append(const char *arg);
+
 
 static void disconnect_and_exit(int code)
 {
@@ -110,6 +130,77 @@ static void disconnect_and_exit(int code)
 }
 
 
+/*
+ * Split argument into old_dir and new_dir and append to tablespace mapping
+ * list.
+ */
+static void
+tablespace_list_append(const char *arg)
+{
+	TablespaceListCell *cell = (TablespaceListCell *) pg_malloc0(sizeof(TablespaceListCell));
+	char		*dst;
+	char		*dst_ptr;
+	const char	*arg_ptr;
+
+	dst_ptr = dst = cell->old_dir;
+	for (arg_ptr = arg; *arg_ptr; arg_ptr++)
+	{
+		if (dst_ptr - dst >= MAXPGPATH)
+		{
+			fprintf(stderr, _("%s: directory name too long\n"),	progname);
+			exit(1);
+		}
+
+		if (*arg_ptr == '\\' && *(arg_ptr + 1) == '=')
+			;  /* skip backslash escaping = */
+		else if (*arg_ptr == '=' && (arg_ptr == arg || *(arg_ptr - 1) != '\\'))
+		{
+			if (*cell->new_dir)
+			{
+				fprintf(stderr, _("%s: multiple \"=\" signs in tablespace mapping\n"), progname);
+				exit(1);
+			}
+			else
+				dst = dst_ptr = cell->new_dir;
+		}
+		else
+			*dst_ptr++ = *arg_ptr;
+	}
+
+	if (!*cell->old_dir || !*cell->new_dir)
+	{
+		fprintf(stderr,
+				_("%s: invalid tablespace mapping format \"%s\", must be \"OLDDIR=NEWDIR\"\n"),
+				progname, arg);
+		exit(1);
+	}
+
+	/* This check isn't absolutely necessary.  But all tablespaces are created
+	 * with absolute directories, so specifying a non-absolute path here would
+	 * just never match, possibly confusing users.  It's also good to be
+	 * consistent with the new_dir check. */
+	if (!is_absolute_path(cell->old_dir))
+	{
+		fprintf(stderr, _("%s: old directory not absolute in tablespace mapping: %s\n"),
+				progname, cell->old_dir);
+		exit(1);
+	}
+
+	if (!is_absolute_path(cell->new_dir))
+	{
+		fprintf(stderr, _("%s: new directory not absolute in tablespace mapping: %s\n"),
+				progname, cell->new_dir);
+		exit(1);
+	}
+
+	if (tablespace_dirs.tail)
+		tablespace_dirs.tail->next = cell;
+	else
+		tablespace_dirs.head = cell;
+	tablespace_dirs.tail = cell;
+}
+
+
 #ifdef HAVE_LIBZ
 static const char *
 get_gz_error(gzFile gzf)
@@ -137,6 +228,8 @@ static void disconnect_and_exit(int code)
 	printf(_("  -F, --format=p|t       output format (plain (default), tar)\n"));
 	printf(_("  -R, --write-recovery-conf\n"
 			 "                         write recovery.conf after backup\n"));
+	printf(_("  -T, --tablespace-mapping=OLDDIR=NEWDIR\n"
+			 "                         relocate tablespace in OLDDIR to NEWDIR\n"));
 	printf(_("  -x, --xlog             include required WAL files in backup (fetch mode)\n"));
 	printf(_("  -X, --xlog-method=fetch|stream\n"
 			 "                         include required WAL files with specified method\n"));
@@ -899,6 +992,52 @@ static void disconnect_and_exit(int code)
 		PQfreemem(copybuf);
 }
 
+
+/*
+ * Retrieve tablespace path, either relocated or original depending on whether
+ * -T was passed or not.
+ */
+static const char *
+get_tablespace_mapping(const char *dir)
+{
+	TablespaceListCell *cell;
+
+	for (cell = tablespace_dirs.head; cell; cell = cell->next)
+		if (strcmp(dir, cell->old_dir) == 0)
+			return cell->new_dir;
+
+	return dir;
+}
+
+
+/*
+ * Update symlinks to reflect relocated tablespace.
+ */
+static void
+update_tablespace_symlink(Oid oid, const char *old_dir)
+{
+	const char *new_dir = get_tablespace_mapping(old_dir);
+
+	if (strcmp(old_dir, new_dir) != 0)
+	{
+		char *linkloc = psprintf("%s/pg_tblspc/%d", basedir, oid);
+
+		if (unlink(linkloc) != 0 && errno != ENOENT)
+		{
+			fprintf(stderr, _("%s: could not remove symbolic link \"%s\": %s"),
+					progname, linkloc, strerror(errno));
+			disconnect_and_exit(1);
+		}
+		if (symlink(new_dir, linkloc) != 0)
+		{
+			fprintf(stderr, _("%s: could not create symbolic link \"%s\": %s"),
+					progname, linkloc, strerror(errno));
+			disconnect_and_exit(1);
+		}
+	}
+}
+
+
 /*
  * Receive a tar format stream from the connection to the server, and unpack
  * the contents of it into a directory. Only files, directories and
@@ -906,8 +1045,7 @@ static void disconnect_and_exit(int code)
  *
  * If the data is for the main data directory, it will be restored in the
  * specified directory. If it's for another tablespace, it will be restored
- * in the original directory, since relocation of tablespaces is not
- * supported.
+ * in the original or mapped directory.
  */
 static void
 ReceiveAndUnpackTarFile(PGconn *conn, PGresult *res, int rownum)
@@ -923,7 +1061,7 @@ static void disconnect_and_exit(int code)
 	if (basetablespace)
 		strcpy(current_path, basedir);
 	else
-		strcpy(current_path, PQgetvalue(res, rownum, 1));
+		strcpy(current_path, get_tablespace_mapping(PQgetvalue(res, rownum, 1)));
 
 	/*
 	 * Get the COPY data
@@ -1503,7 +1641,10 @@ static void disconnect_and_exit(int code)
 		 * we do anything anyway.
 		 */
 		if (format == 'p' && !PQgetisnull(res, i, 1))
-			verify_dir_is_empty_or_create(PQgetvalue(res, i, 1));
+		{
+			char *path = (char *) get_tablespace_mapping(PQgetvalue(res, i, 1));
+			verify_dir_is_empty_or_create(path);
+		}
 	}
 
 	/*
@@ -1545,6 +1686,17 @@ static void disconnect_and_exit(int code)
 		progress_report(PQntuples(res), NULL, true);
 		fprintf(stderr, "\n");	/* Need to move to next line */
 	}
+
+	if (format == 'p' && tablespace_dirs.head != NULL)
+	{
+		for (i = 0; i < PQntuples(res); i++)
+		{
+			Oid tblspc_oid = atooid(PQgetvalue(res, i, 0));
+			if (tblspc_oid)
+				update_tablespace_symlink(tblspc_oid, PQgetvalue(res, i, 1));
+		}
+	}
+
 	PQclear(res);
 
 	/*
@@ -1696,6 +1848,7 @@ static void disconnect_and_exit(int code)
 		{"format", required_argument, NULL, 'F'},
 		{"checkpoint", required_argument, NULL, 'c'},
 		{"write-recovery-conf", no_argument, NULL, 'R'},
+		{"tablespace-mapping", required_argument, NULL, 'T'},
 		{"xlog", no_argument, NULL, 'x'},
 		{"xlog-method", required_argument, NULL, 'X'},
 		{"gzip", no_argument, NULL, 'z'},
@@ -1735,7 +1888,7 @@ static void disconnect_and_exit(int code)
 		}
 	}
 
-	while ((c = getopt_long(argc, argv, "D:F:RxX:l:zZ:d:c:h:p:U:s:wWvP",
+	while ((c = getopt_long(argc, argv, "D:F:RT:xX:l:zZ:d:c:h:p:U:s:wWvP",
 							long_options, &option_index)) != -1)
 	{
 		switch (c)
@@ -1759,6 +1912,9 @@ static void disconnect_and_exit(int code)
 			case 'R':
 				writerecoveryconf = true;
 				break;
+			case 'T':
+				tablespace_list_append(optarg);
+				break;
 			case 'x':
 				if (includewal)
 				{
-- 
1.8.5.5

diff --git a/src/bin/pg_basebackup/t/010_pg_basebackup.pl b/src/bin/pg_basebackup/t/010_pg_basebackup.pl
index b4c0471..cf7c4b6 100644
--- a/src/bin/pg_basebackup/t/010_pg_basebackup.pl
+++ b/src/bin/pg_basebackup/t/010_pg_basebackup.pl
@@ -2,7 +2,7 @@
 use warnings;
 use Cwd;
 use TestLib;
-use Test::More tests => 19;
+use Test::More tests => 31;
 
 program_help_ok('pg_basebackup');
 program_version_ok('pg_basebackup');
@@ -48,6 +48,47 @@
 note("tablespace tars are @tblspc_tars");
 is(scalar(@tblspc_tars), 1, 'one tablespace tar was created');
 
+command_fails(['pg_basebackup', '-D', "$tempdir/backup1", '-Fp'],
+			  'plain format with tablespaces fails without tablespace mapping');
+
+command_ok(['pg_basebackup', '-D', "$tempdir/backup1", '-Fp',
+			"-T$tempdir/tblspc1=$tempdir/tbackup/tblspc1"],
+		   'plain format with tablespaces succeeds with tablespace mapping');
+ok(-d "$tempdir/tbackup/tblspc1", 'tablespace was relocated');
+opendir(my $dh, "$tempdir/pgdata/pg_tblspc") or die;
+ok((grep { -l "$tempdir/backup1/pg_tblspc/$_" and readlink "$tempdir/backup1/pg_tblspc/$_" eq "$tempdir/tbackup/tblspc1" } readdir($dh)),
+   "tablespace symlink was updated");
+closedir $dh;
+
+mkdir "$tempdir/tbl=spc2";
+psql 'postgres', "DROP TABLE test1;";
+psql 'postgres', "DROP TABLESPACE tblspc1;";
+psql 'postgres', "CREATE TABLESPACE tblspc2 LOCATION '$tempdir/tbl=spc2';";
+command_ok(['pg_basebackup', '-D', "$tempdir/backup3", '-Fp',
+			"-T$tempdir/tbl\\=spc2=$tempdir/tbackup/tbl\\=spc2"],
+		   'mapping tablespace with = sign in path');
+ok(-d "$tempdir/tbackup/tbl=spc2", 'tablespace with = sign was relocated');
+
+psql 'postgres', "DROP TABLESPACE tblspc2;";
+
+command_fails(['pg_basebackup', '-D', "$tempdir/backup_foo", '-Fp',
+			   "-T=/foo"],
+			  '-T with empty old directory fails');
+command_fails(['pg_basebackup', '-D', "$tempdir/backup_foo", '-Fp',
+			   "-T/foo="],
+			  '-T with empty new directory fails');
+command_fails(['pg_basebackup', '-D', "$tempdir/backup_foo", '-Fp',
+			   "-T/foo=/bar=/baz"],
+			  '-T with multiple = fails');
+command_fails(['pg_basebackup', '-D', "$tempdir/backup_foo", '-Fp',
+			   "-Tfoo=/bar"],
+			  '-T with old directory not absolute fails');
+command_fails(['pg_basebackup', '-D', "$tempdir/backup_foo", '-Fp',
+			   "-T/foo=bar"],
+			  '-T with new directory not absolute fails');
+command_fails(['pg_basebackup', '-D', "$tempdir/backup_foo", '-Fp',
+			   "-Tfoo"],
+			  '-T with invalid format fails');
 
 our $TODO = 'https://commitfest.postgresql.org/action/patch_view?id=1303';