From 46bd885f0e5ae146f7b08d08bb54747c7cee0c1c Mon Sep 17 00:00:00 2001 From: Bertrand Drouvot Date: Mon, 19 Aug 2024 07:40:10 +0000 Subject: [PATCH v2 5/5] Define PG_TBLSPC_DIR Replace most of the places where "pg_tblspc" is used in .c files with a new PG_TBLSPC_DIR define. The places where it is not done is for consistency with the existing PG_STAT_TMP_DIR define. --- src/backend/access/transam/xlog.c | 20 +++++------ src/backend/access/transam/xlogrecovery.c | 26 +++++++------- src/backend/backup/backup_manifest.c | 3 +- src/backend/backup/basebackup.c | 10 +++--- src/backend/commands/dbcommands.c | 6 ++-- src/backend/commands/tablespace.c | 14 ++++---- src/backend/storage/file/fd.c | 39 +++++++++++---------- src/backend/storage/file/reinit.c | 16 ++++----- src/backend/utils/adt/dbsize.c | 8 ++--- src/backend/utils/adt/misc.c | 6 ++-- src/backend/utils/cache/relcache.c | 4 +-- src/bin/pg_checksums/pg_checksums.c | 8 ++--- src/bin/pg_combinebackup/pg_combinebackup.c | 35 +++++++++--------- src/bin/pg_rewind/file_ops.c | 4 +-- src/bin/pg_upgrade/exec.c | 2 +- src/common/file_utils.c | 9 ++--- src/common/relpath.c | 20 +++++------ src/fe_utils/astreamer_file.c | 13 ++++--- src/include/common/relpath.h | 4 +++ 19 files changed, 129 insertions(+), 118 deletions(-) 17.5% src/backend/access/transam/ 5.5% src/backend/backup/ 8.5% src/backend/commands/ 23.3% src/backend/storage/file/ 5.5% src/backend/utils/adt/ 3.5% src/bin/pg_checksums/ 14.8% src/bin/pg_combinebackup/ 10.6% src/common/ 5.3% src/fe_utils/ 4.9% src/ diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c index ee0fb0e28f..48718cbdf3 100644 --- a/src/backend/access/transam/xlog.c +++ b/src/backend/access/transam/xlog.c @@ -5558,8 +5558,8 @@ StartupXLOG(void) * in place if the database had been cleanly shut down, but it seems * safest to just remove them always and let them be rebuilt during the * first backend startup. These files needs to be removed from all - * directories including pg_tblspc, however the symlinks are created only - * after reading tablespace_map file in case of archive recovery from + * directories including PG_TBLSPC_DIR, however the symlinks are created + * only after reading tablespace_map file in case of archive recovery from * backup, so needs to clear old relcache files here after creating * symlinks. */ @@ -8944,10 +8944,10 @@ do_pg_backup_start(const char *backupidstr, bool fast, List **tablespaces, datadirpathlen = strlen(DataDir); /* Collect information about all tablespaces */ - tblspcdir = AllocateDir("pg_tblspc"); - while ((de = ReadDir(tblspcdir, "pg_tblspc")) != NULL) + tblspcdir = AllocateDir(PG_TBLSPC_DIR); + while ((de = ReadDir(tblspcdir, PG_TBLSPC_DIR)) != NULL) { - char fullpath[MAXPGPATH + 10]; + char fullpath[MAXPGPATH + sizeof(PG_TBLSPC_DIR)]; char linkpath[MAXPGPATH]; char *relpath = NULL; char *s; @@ -8970,7 +8970,7 @@ do_pg_backup_start(const char *backupidstr, bool fast, List **tablespaces, if (*badp != '\0' || errno == EINVAL || errno == ERANGE) continue; - snprintf(fullpath, sizeof(fullpath), "pg_tblspc/%s", de->d_name); + snprintf(fullpath, sizeof(fullpath), "%s/%s", PG_TBLSPC_DIR, de->d_name); de_type = get_dirent_type(fullpath, de, false, ERROR); @@ -9025,14 +9025,14 @@ do_pg_backup_start(const char *backupidstr, bool fast, List **tablespaces, { /* * It's possible to use allow_in_place_tablespaces to create - * directories directly under pg_tblspc, for testing purposes - * only. + * directories directly under PG_TBLSPC_DIR, for testing + * purposes only. * * In this case, we store a relative path rather than an * absolute path into the tablespaceinfo. */ - snprintf(linkpath, sizeof(linkpath), "pg_tblspc/%s", - de->d_name); + snprintf(linkpath, sizeof(linkpath), "%s/%s", + PG_TBLSPC_DIR, de->d_name); relpath = pstrdup(linkpath); } else diff --git a/src/backend/access/transam/xlogrecovery.c b/src/backend/access/transam/xlogrecovery.c index ad817fbca6..9ae72933d7 100644 --- a/src/backend/access/transam/xlogrecovery.c +++ b/src/backend/access/transam/xlogrecovery.c @@ -677,7 +677,7 @@ InitWalRecovery(ControlFileData *ControlFile, bool *wasShutdown_ptr, tablespaceinfo *ti = lfirst(lc); char *linkloc; - linkloc = psprintf("pg_tblspc/%u", ti->oid); + linkloc = psprintf("%s/%u", PG_TBLSPC_DIR, ti->oid); /* * Remove the existing symlink if any and Create the symlink @@ -2138,11 +2138,11 @@ xlogrecovery_redo(XLogReaderState *record, TimeLineID replayTLI) } /* - * Verify that, in non-test mode, ./pg_tblspc doesn't contain any real + * Verify that, in non-test mode, ./PG_TBLSPC_DIR doesn't contain any real * directories. * * Replay of database creation XLOG records for databases that were later - * dropped can create fake directories in pg_tblspc. By the time consistency + * dropped can create fake directories in PG_TBLSPC_DIR. By the time consistency * is reached these directories should have been removed; here we verify * that this did indeed happen. This is to be called at the point where * consistent state is reached. @@ -2157,23 +2157,23 @@ CheckTablespaceDirectory(void) DIR *dir; struct dirent *de; - dir = AllocateDir("pg_tblspc"); - while ((de = ReadDir(dir, "pg_tblspc")) != NULL) + dir = AllocateDir(PG_TBLSPC_DIR); + while ((de = ReadDir(dir, PG_TBLSPC_DIR)) != NULL) { - char path[MAXPGPATH + 10]; + char path[MAXPGPATH + sizeof(PG_TBLSPC_DIR)]; /* Skip entries of non-oid names */ if (strspn(de->d_name, "0123456789") != strlen(de->d_name)) continue; - snprintf(path, sizeof(path), "pg_tblspc/%s", de->d_name); + snprintf(path, sizeof(path), "%s/%s", PG_TBLSPC_DIR, de->d_name); if (get_dirent_type(path, de, false, ERROR) != PGFILETYPE_LNK) ereport(allow_in_place_tablespaces ? WARNING : PANIC, (errcode(ERRCODE_DATA_CORRUPTED), errmsg("unexpected directory entry \"%s\" found in %s", - de->d_name, "pg_tblspc/"), - errdetail("All directory entries in pg_tblspc/ should be symbolic links."), + de->d_name, PG_TBLSPC_DIR), + errdetail("All directory entries in %s/ should be symbolic links.", PG_TBLSPC_DIR), errhint("Remove those directories, or set \"allow_in_place_tablespaces\" to ON transiently to let recovery complete."))); } } @@ -2247,10 +2247,10 @@ CheckRecoveryConsistency(void) XLogCheckInvalidPages(); /* - * Check that pg_tblspc doesn't contain any real directories. Replay - * of Database/CREATE_* records may have created fictitious tablespace - * directories that should have been removed by the time consistency - * was reached. + * Check that PG_TBLSPC_DIR doesn't contain any real directories. + * Replay of Database/CREATE_* records may have created fictitious + * tablespace directories that should have been removed by the time + * consistency was reached. */ CheckTablespaceDirectory(); diff --git a/src/backend/backup/backup_manifest.c b/src/backend/backup/backup_manifest.c index 4357cfa31d..a2e2f86332 100644 --- a/src/backend/backup/backup_manifest.c +++ b/src/backend/backup/backup_manifest.c @@ -16,6 +16,7 @@ #include "access/xlog.h" #include "backup/backup_manifest.h" #include "backup/basebackup_sink.h" +#include "common/relpath.h" #include "mb/pg_wchar.h" #include "utils/builtins.h" #include "utils/json.h" @@ -117,7 +118,7 @@ AddFileToBackupManifest(backup_manifest_info *manifest, Oid spcoid, */ if (OidIsValid(spcoid)) { - snprintf(pathbuf, sizeof(pathbuf), "pg_tblspc/%u/%s", spcoid, + snprintf(pathbuf, sizeof(pathbuf), "%s/%u/%s", PG_TBLSPC_DIR, spcoid, pathname); pathname = pathbuf; } diff --git a/src/backend/backup/basebackup.c b/src/backend/backup/basebackup.c index de16afac74..9612fe33ce 100644 --- a/src/backend/backup/basebackup.c +++ b/src/backend/backup/basebackup.c @@ -1405,8 +1405,8 @@ sendDir(bbsink *sink, const char *path, int basepathlen, bool sizeonly, continue; /* don't recurse into pg_wal */ } - /* Allow symbolic links in pg_tblspc only */ - if (strcmp(path, "./pg_tblspc") == 0 && S_ISLNK(statbuf.st_mode)) + /* Allow symbolic links in PG_TBLSPC_DIR only */ + if (strcmp(path, RELATIVE_PG_TBLSPC_DIR) == 0 && S_ISLNK(statbuf.st_mode)) { char linkpath[MAXPGPATH]; int rllen; @@ -1462,9 +1462,9 @@ sendDir(bbsink *sink, const char *path, int basepathlen, bool sizeonly, } /* - * skip sending directories inside pg_tblspc, if not required. + * skip sending directories inside PG_TBLSPC_DIR, if not required. */ - if (strcmp(pathbuf, "./pg_tblspc") == 0 && !sendtblspclinks) + if (strcmp(pathbuf, RELATIVE_PG_TBLSPC_DIR) == 0 && !sendtblspclinks) skip_this_dir = true; if (!skip_this_dir) @@ -1488,7 +1488,7 @@ sendDir(bbsink *sink, const char *path, int basepathlen, bool sizeonly, if (OidIsValid(spcoid)) { relspcoid = spcoid; - lookup_path = psprintf("pg_tblspc/%u/%s", spcoid, + lookup_path = psprintf("%s/%u/%s", PG_TBLSPC_DIR, spcoid, tarfilename); } else diff --git a/src/backend/commands/dbcommands.c b/src/backend/commands/dbcommands.c index d00ae40e19..01585232a3 100644 --- a/src/backend/commands/dbcommands.c +++ b/src/backend/commands/dbcommands.c @@ -3243,9 +3243,9 @@ database_is_invalid_oid(Oid dboid) * removed before the server stopped. Since we expect that the directory will * be gone before reaching recovery consistency, and we have no knowledge about * the tablespace other than its OID here, we create a real directory under - * pg_tblspc here instead of restoring the symlink. + * PG_TBLSPC_DIR here instead of restoring the symlink. * - * If only_tblspc is true, then the requested directory must be in pg_tblspc/ + * If only_tblspc is true, then the requested directory must be in PG_TBLSPC_DIR/ */ static void recovery_create_dbdir(char *path, bool only_tblspc) @@ -3257,7 +3257,7 @@ recovery_create_dbdir(char *path, bool only_tblspc) if (stat(path, &st) == 0) return; - if (only_tblspc && strstr(path, "pg_tblspc/") == NULL) + if (only_tblspc && strstr(path, PG_TBLSPC_DIR_SLASH) == NULL) elog(PANIC, "requested to created invalid directory: %s", path); if (reachedConsistency && !allow_in_place_tablespaces) diff --git a/src/backend/commands/tablespace.c b/src/backend/commands/tablespace.c index 113b480731..9b8f02a995 100644 --- a/src/backend/commands/tablespace.c +++ b/src/backend/commands/tablespace.c @@ -13,13 +13,13 @@ * files within a tablespace into database-specific subdirectories. * * To support file access via the information given in RelFileLocator, we - * maintain a symbolic-link map in $PGDATA/pg_tblspc. The symlinks are + * maintain a symbolic-link map in $PGDATA/PG_TBLSPC_DIR. The symlinks are * named by tablespace OIDs and point to the actual tablespace directories. * There is also a per-cluster version directory in each tablespace. * Thus the full path to an arbitrary file is - * $PGDATA/pg_tblspc/spcoid/PG_MAJORVER_CATVER/dboid/relfilenumber + * $PGDATA/PG_TBLSPC_DIR/spcoid/PG_MAJORVER_CATVER/dboid/relfilenumber * e.g. - * $PGDATA/pg_tblspc/20981/PG_9.0_201002161/719849/83292814 + * $PGDATA/PG_TBLSPC_DIR/20981/PG_9.0_201002161/719849/83292814 * * There are two tablespaces created at initdb time: pg_global (for shared * tables) and pg_default (for everything else). For backwards compatibility @@ -565,7 +565,7 @@ DropTableSpace(DropTableSpaceStmt *stmt) /* * create_tablespace_directories * - * Attempt to create filesystem infrastructure linking $PGDATA/pg_tblspc/ + * Attempt to create filesystem infrastructure linking $PGDATA/PG_TBLSPC_DIR/ * to the specified directory */ static void @@ -576,7 +576,7 @@ create_tablespace_directories(const char *location, const Oid tablespaceoid) struct stat st; bool in_place; - linkloc = psprintf("pg_tblspc/%u", tablespaceoid); + linkloc = psprintf("%s/%u", PG_TBLSPC_DIR, tablespaceoid); /* * If we're asked to make an 'in place' tablespace, create the directory @@ -692,7 +692,7 @@ destroy_tablespace_directories(Oid tablespaceoid, bool redo) char *subfile; struct stat st; - linkloc_with_version_dir = psprintf("pg_tblspc/%u/%s", tablespaceoid, + linkloc_with_version_dir = psprintf("%s/%u/%s", PG_TBLSPC_DIR, tablespaceoid, TABLESPACE_VERSION_DIRECTORY); /* @@ -873,7 +873,7 @@ directory_is_empty(const char *path) /* * remove_tablespace_symlink * - * This function removes symlinks in pg_tblspc. On Windows, junction points + * This function removes symlinks in PG_TBLSPC_DIR. On Windows, junction points * act like directories so we must be able to apply rmdir. This function * works like the symlink removal code in destroy_tablespace_directories, * except that failure to remove is always an ERROR. But if the file doesn't diff --git a/src/backend/storage/file/fd.c b/src/backend/storage/file/fd.c index 3944321ff3..bf309ba611 100644 --- a/src/backend/storage/file/fd.c +++ b/src/backend/storage/file/fd.c @@ -1790,8 +1790,8 @@ TempTablespacePath(char *path, Oid tablespace) else { /* All other tablespaces are accessed via symlinks */ - snprintf(path, MAXPGPATH, "pg_tblspc/%u/%s/%s", - tablespace, TABLESPACE_VERSION_DIRECTORY, + snprintf(path, MAXPGPATH, "%s/%u/%s/%s", + PG_TBLSPC_DIR, tablespace, TABLESPACE_VERSION_DIRECTORY, PG_TEMP_FILES_DIR); } } @@ -3273,7 +3273,7 @@ CleanupTempFiles(bool isCommit, bool isProcExit) void RemovePgTempFiles(void) { - char temp_path[MAXPGPATH + 10 + sizeof(TABLESPACE_VERSION_DIRECTORY) + sizeof(PG_TEMP_FILES_DIR)]; + char temp_path[MAXPGPATH + sizeof(PG_TBLSPC_DIR) + sizeof(TABLESPACE_VERSION_DIRECTORY) + sizeof(PG_TEMP_FILES_DIR)]; DIR *spc_dir; struct dirent *spc_de; @@ -3287,20 +3287,21 @@ RemovePgTempFiles(void) /* * Cycle through temp directories for all non-default tablespaces. */ - spc_dir = AllocateDir("pg_tblspc"); + spc_dir = AllocateDir(PG_TBLSPC_DIR); - while ((spc_de = ReadDirExtended(spc_dir, "pg_tblspc", LOG)) != NULL) + while ((spc_de = ReadDirExtended(spc_dir, PG_TBLSPC_DIR, LOG)) != NULL) { if (strcmp(spc_de->d_name, ".") == 0 || strcmp(spc_de->d_name, "..") == 0) continue; - snprintf(temp_path, sizeof(temp_path), "pg_tblspc/%s/%s/%s", - spc_de->d_name, TABLESPACE_VERSION_DIRECTORY, PG_TEMP_FILES_DIR); + snprintf(temp_path, sizeof(temp_path), "%s/%s/%s/%s", + PG_TBLSPC_DIR, spc_de->d_name, TABLESPACE_VERSION_DIRECTORY, + PG_TEMP_FILES_DIR); RemovePgTempFilesInDir(temp_path, true, false); - snprintf(temp_path, sizeof(temp_path), "pg_tblspc/%s/%s", - spc_de->d_name, TABLESPACE_VERSION_DIRECTORY); + snprintf(temp_path, sizeof(temp_path), "%s/%s/%s", + PG_TBLSPC_DIR, spc_de->d_name, TABLESPACE_VERSION_DIRECTORY); RemovePgTempRelationFiles(temp_path); } @@ -3523,7 +3524,7 @@ do_syncfs(const char *path) * all potential filesystem, depending on recovery_init_sync_method setting. * * We fsync regular files and directories wherever they are, but we - * follow symlinks only for pg_wal and immediately under pg_tblspc. + * follow symlinks only for pg_wal and immediately under PG_TBLSPC_DIR. * Other symlinks are presumed to point at files we're not responsible * for fsyncing, and might not have privileges to write at all. * @@ -3587,15 +3588,15 @@ SyncDataDirectory(void) /* Sync the top level pgdata directory. */ do_syncfs("."); /* If any tablespaces are configured, sync each of those. */ - dir = AllocateDir("pg_tblspc"); - while ((de = ReadDirExtended(dir, "pg_tblspc", LOG))) + dir = AllocateDir(PG_TBLSPC_DIR); + while ((de = ReadDirExtended(dir, PG_TBLSPC_DIR, LOG))) { char path[MAXPGPATH]; if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue; - snprintf(path, MAXPGPATH, "pg_tblspc/%s", de->d_name); + snprintf(path, MAXPGPATH, "%s/%s", PG_TBLSPC_DIR, de->d_name); do_syncfs(path); } FreeDir(dir); @@ -3618,7 +3619,7 @@ SyncDataDirectory(void) walkdir(".", pre_sync_fname, false, DEBUG1); if (xlog_is_symlink) walkdir("pg_wal", pre_sync_fname, false, DEBUG1); - walkdir("pg_tblspc", pre_sync_fname, true, DEBUG1); + walkdir(PG_TBLSPC_DIR, pre_sync_fname, true, DEBUG1); #endif /* Prepare to report progress syncing the data directory via fsync. */ @@ -3628,15 +3629,15 @@ SyncDataDirectory(void) * Now we do the fsync()s in the same order. * * The main call ignores symlinks, so in addition to specially processing - * pg_wal if it's a symlink, pg_tblspc has to be visited separately with - * process_symlinks = true. Note that if there are any plain directories - * in pg_tblspc, they'll get fsync'd twice. That's not an expected case - * so we don't worry about optimizing it. + * pg_wal if it's a symlink, PG_TBLSPC_DIR has to be visited separately + * with process_symlinks = true. Note that if there are any plain + * directories in PG_TBLSPC_DIR, they'll get fsync'd twice. That's not an + * expected case so we don't worry about optimizing it. */ walkdir(".", datadir_fsync_fname, false, LOG); if (xlog_is_symlink) walkdir("pg_wal", datadir_fsync_fname, false, LOG); - walkdir("pg_tblspc", datadir_fsync_fname, true, LOG); + walkdir(PG_TBLSPC_DIR, datadir_fsync_fname, true, LOG); } /* diff --git a/src/backend/storage/file/reinit.c b/src/backend/storage/file/reinit.c index f1cd1a38d9..ee63c4e4e5 100644 --- a/src/backend/storage/file/reinit.c +++ b/src/backend/storage/file/reinit.c @@ -46,7 +46,7 @@ typedef struct void ResetUnloggedRelations(int op) { - char temp_path[MAXPGPATH + 10 + sizeof(TABLESPACE_VERSION_DIRECTORY)]; + char temp_path[MAXPGPATH + sizeof(PG_TBLSPC_DIR) + sizeof(TABLESPACE_VERSION_DIRECTORY)]; DIR *spc_dir; struct dirent *spc_de; MemoryContext tmpctx, @@ -77,16 +77,16 @@ ResetUnloggedRelations(int op) /* * Cycle through directories for all non-default tablespaces. */ - spc_dir = AllocateDir("pg_tblspc"); + spc_dir = AllocateDir(PG_TBLSPC_DIR); - while ((spc_de = ReadDir(spc_dir, "pg_tblspc")) != NULL) + while ((spc_de = ReadDir(spc_dir, PG_TBLSPC_DIR)) != NULL) { if (strcmp(spc_de->d_name, ".") == 0 || strcmp(spc_de->d_name, "..") == 0) continue; - snprintf(temp_path, sizeof(temp_path), "pg_tblspc/%s/%s", - spc_de->d_name, TABLESPACE_VERSION_DIRECTORY); + snprintf(temp_path, sizeof(temp_path), "%s/%s/%s", + PG_TBLSPC_DIR, spc_de->d_name, TABLESPACE_VERSION_DIRECTORY); ResetUnloggedRelationsInTablespaceDir(temp_path, op); } @@ -114,9 +114,9 @@ ResetUnloggedRelationsInTablespaceDir(const char *tsdirname, int op) /* * If we get ENOENT on a tablespace directory, log it and return. This * can happen if a previous DROP TABLESPACE crashed between removing the - * tablespace directory and removing the symlink in pg_tblspc. We don't - * really want to prevent database startup in that scenario, so let it - * pass instead. Any other type of error will be reported by ReadDir + * tablespace directory and removing the symlink in PG_TBLSPC_DIR. We + * don't really want to prevent database startup in that scenario, so let + * it pass instead. Any other type of error will be reported by ReadDir * (causing a startup failure). */ if (ts_dir == NULL && errno == ENOENT) diff --git a/src/backend/utils/adt/dbsize.c b/src/backend/utils/adt/dbsize.c index b2d9cc2792..e63e99c141 100644 --- a/src/backend/utils/adt/dbsize.c +++ b/src/backend/utils/adt/dbsize.c @@ -143,7 +143,7 @@ calculate_database_size(Oid dbOid) totalsize = db_dir_size(pathname); /* Scan the non-default tablespaces */ - snprintf(dirpath, MAXPGPATH, "pg_tblspc"); + snprintf(dirpath, MAXPGPATH, PG_TBLSPC_DIR); dirdesc = AllocateDir(dirpath); while ((direntry = ReadDir(dirdesc, dirpath)) != NULL) @@ -154,8 +154,8 @@ calculate_database_size(Oid dbOid) strcmp(direntry->d_name, "..") == 0) continue; - snprintf(pathname, sizeof(pathname), "pg_tblspc/%s/%s/%u", - direntry->d_name, TABLESPACE_VERSION_DIRECTORY, dbOid); + snprintf(pathname, sizeof(pathname), "%s/%s/%s/%u", + PG_TBLSPC_DIR, direntry->d_name, TABLESPACE_VERSION_DIRECTORY, dbOid); totalsize += db_dir_size(pathname); } @@ -227,7 +227,7 @@ calculate_tablespace_size(Oid tblspcOid) else if (tblspcOid == GLOBALTABLESPACE_OID) snprintf(tblspcPath, MAXPGPATH, "global"); else - snprintf(tblspcPath, MAXPGPATH, "pg_tblspc/%u/%s", tblspcOid, + snprintf(tblspcPath, MAXPGPATH, "%s/%u/%s", PG_TBLSPC_DIR, tblspcOid, TABLESPACE_VERSION_DIRECTORY); dirdesc = AllocateDir(tblspcPath); diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c index 0e6c45807a..af6123d2f6 100644 --- a/src/backend/utils/adt/misc.c +++ b/src/backend/utils/adt/misc.c @@ -242,7 +242,7 @@ pg_tablespace_databases(PG_FUNCTION_ARGS) if (tablespaceOid == DEFAULTTABLESPACE_OID) location = "base"; else - location = psprintf("pg_tblspc/%u/%s", tablespaceOid, + location = psprintf("%s/%u/%s", PG_TBLSPC_DIR, tablespaceOid, TABLESPACE_VERSION_DIRECTORY); dirdesc = AllocateDir(location); @@ -323,9 +323,9 @@ pg_tablespace_location(PG_FUNCTION_ARGS) /* * Find the location of the tablespace by reading the symbolic link that - * is in pg_tblspc/. + * is in PG_TBLSPC_DIR/. */ - snprintf(sourcepath, sizeof(sourcepath), "pg_tblspc/%u", tablespaceOid); + snprintf(sourcepath, sizeof(sourcepath), "%s/%u", PG_TBLSPC_DIR, tablespaceOid); /* * Before reading the link, check if the source path is a link or a diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c index 66ed24e401..63efc55f09 100644 --- a/src/backend/utils/cache/relcache.c +++ b/src/backend/utils/cache/relcache.c @@ -6800,10 +6800,10 @@ RelationCacheInitFilePostInvalidate(void) void RelationCacheInitFileRemove(void) { - const char *tblspcdir = "pg_tblspc"; + const char *tblspcdir = PG_TBLSPC_DIR; DIR *dir; struct dirent *de; - char path[MAXPGPATH + 10 + sizeof(TABLESPACE_VERSION_DIRECTORY)]; + char path[MAXPGPATH + sizeof(PG_TBLSPC_DIR) + sizeof(TABLESPACE_VERSION_DIRECTORY)]; snprintf(path, sizeof(path), "global/%s", RELCACHE_INIT_FILENAME); diff --git a/src/bin/pg_checksums/pg_checksums.c b/src/bin/pg_checksums/pg_checksums.c index b5bb0e7887..ea2c2346ca 100644 --- a/src/bin/pg_checksums/pg_checksums.c +++ b/src/bin/pg_checksums/pg_checksums.c @@ -383,12 +383,12 @@ scan_directory(const char *basedir, const char *subdir, bool sizeonly) else if (S_ISDIR(st.st_mode) || S_ISLNK(st.st_mode)) { /* - * If going through the entries of pg_tblspc, we assume to operate + * If going through the entries of PG_TBLSPC_DIR, we assume to operate * on tablespace locations where only TABLESPACE_VERSION_DIRECTORY * is valid, resolving the linked locations and dive into them * directly. */ - if (strncmp("pg_tblspc", subdir, strlen("pg_tblspc")) == 0) + if (strncmp(PG_TBLSPC_DIR, subdir, strlen(PG_TBLSPC_DIR)) == 0) { char tblspc_path[MAXPGPATH]; struct stat tblspc_st; @@ -593,12 +593,12 @@ main(int argc, char *argv[]) { total_size = scan_directory(DataDir, "global", true); total_size += scan_directory(DataDir, "base", true); - total_size += scan_directory(DataDir, "pg_tblspc", true); + total_size += scan_directory(DataDir, PG_TBLSPC_DIR, true); } (void) scan_directory(DataDir, "global", false); (void) scan_directory(DataDir, "base", false); - (void) scan_directory(DataDir, "pg_tblspc", false); + (void) scan_directory(DataDir, PG_TBLSPC_DIR, false); if (showprogress) progress_report(true); diff --git a/src/bin/pg_combinebackup/pg_combinebackup.c b/src/bin/pg_combinebackup/pg_combinebackup.c index 9ded5a2140..307a8c7fc1 100644 --- a/src/bin/pg_combinebackup/pg_combinebackup.c +++ b/src/bin/pg_combinebackup/pg_combinebackup.c @@ -318,7 +318,7 @@ main(int argc, char *argv[]) * for those directories to be cleaned up on failure. In-place tablespaces * aren't handled at this stage because they're located beneath the main * output directory, and thus the cleanup of that directory will get rid - * of them. Plus, the pg_tblspc directory that needs to contain them + * of them. Plus, the PG_TBLSPC_DIR directory that needs to contain them * doesn't exist yet. */ atexit(cleanup_directories_atexit); @@ -366,14 +366,14 @@ main(int argc, char *argv[]) /* * If it's a normal tablespace, we need to set up a symbolic link from - * pg_tblspc/${OID} to the target directory; if it's an in-place - * tablespace, we need to create a directory at pg_tblspc/${OID}. + * PG_TBLSPC_DIR/${OID} to the target directory; if it's an in-place + * tablespace, we need to create a directory at PG_TBLSPC_DIR/${OID}. */ if (!ts->in_place) { char linkpath[MAXPGPATH]; - snprintf(linkpath, MAXPGPATH, "%s/pg_tblspc/%u", opt.output, + snprintf(linkpath, MAXPGPATH, "%s/%s/%u", opt.output, PG_TBLSPC_DIR, ts->oid); if (opt.dry_run) @@ -844,8 +844,9 @@ process_directory_recursively(Oid tsoid, /* * Classify this directory. * - * We set is_pg_tblspc only for the toplevel pg_tblspc directory, because - * the symlinks in that specific directory require special handling. + * We set is_pg_tblspc only for the toplevel PG_TBLSPC_DIR directory, + * because the symlinks in that specific directory require special + * handling. * * We set is_pg_wal for the toplevel WAL directory and all of its * subdirectories, because those files are not included in the backup @@ -860,19 +861,19 @@ process_directory_recursively(Oid tsoid, * strange name like INCREMENTAL.config and then complaining that * incremental backups don't work properly. The test here is a bit tricky: * incremental files occur in subdirectories of base, in pg_global itself, - * and in subdirectories of pg_tblspc only if in-place tablespaces are + * and in subdirectories of PG_TBLSPC_DIR only if in-place tablespaces are * used. */ if (OidIsValid(tsoid)) is_incremental_dir = true; else if (relative_path != NULL) { - is_pg_tblspc = strcmp(relative_path, "pg_tblspc") == 0; + is_pg_tblspc = strcmp(relative_path, PG_TBLSPC_DIR) == 0; is_pg_wal = (strcmp(relative_path, "pg_wal") == 0 || strncmp(relative_path, "pg_wal/", 7) == 0); is_incremental_dir = strncmp(relative_path, "base/", 5) == 0 || strcmp(relative_path, "global") == 0 || - strncmp(relative_path, "pg_tblspc/", 10) == 0; + strncmp(relative_path, PG_TBLSPC_DIR_SLASH, 10) == 0; } /* @@ -895,7 +896,7 @@ process_directory_recursively(Oid tsoid, strlcpy(ifulldir, input_directory, MAXPGPATH); strlcpy(ofulldir, output_directory, MAXPGPATH); if (OidIsValid(tsoid)) - snprintf(manifest_prefix, MAXPGPATH, "pg_tblspc/%u/", tsoid); + snprintf(manifest_prefix, MAXPGPATH, "%s/%u/", PG_TBLSPC_DIR, tsoid); else manifest_prefix[0] = '\0'; } @@ -906,8 +907,8 @@ process_directory_recursively(Oid tsoid, snprintf(ofulldir, MAXPGPATH, "%s/%s", output_directory, relative_path); if (OidIsValid(tsoid)) - snprintf(manifest_prefix, MAXPGPATH, "pg_tblspc/%u/%s/", - tsoid, relative_path); + snprintf(manifest_prefix, MAXPGPATH, "%s/%u/%s/", + PG_TBLSPC_DIR, tsoid, relative_path); else snprintf(manifest_prefix, MAXPGPATH, "%s/", relative_path); } @@ -956,7 +957,7 @@ process_directory_recursively(Oid tsoid, exit(1); /* - * If we're processing pg_tblspc, then check whether the filename + * If we're processing PG_TBLSPC_DIR, then check whether the filename * looks like it could be a tablespace OID. If so, and if the * directory entry is a symbolic link or a directory, skip it. * @@ -1235,7 +1236,7 @@ reset_directory_cleanup_list(void) } /* - * Scan the pg_tblspc directory of the final input backup to get a canonical + * Scan the PG_TBLSPC_DIR directory of the final input backup to get a canonical * list of what tablespaces are part of the backup. * * 'pathname' should be the path to the toplevel backup directory for the @@ -1249,7 +1250,7 @@ scan_for_existing_tablespaces(char *pathname, cb_options *opt) struct dirent *de; cb_tablespace *tslist = NULL; - snprintf(pg_tblspc, MAXPGPATH, "%s/pg_tblspc", pathname); + snprintf(pg_tblspc, MAXPGPATH, "%s/%s", pathname, PG_TBLSPC_DIR); pg_log_debug("scanning \"%s\"", pg_tblspc); if ((dir = opendir(pg_tblspc)) == NULL) @@ -1344,8 +1345,8 @@ scan_for_existing_tablespaces(char *pathname, cb_options *opt) * we just record the paths within the data directories. */ snprintf(ts->old_dir, MAXPGPATH, "%s/%s", pg_tblspc, de->d_name); - snprintf(ts->new_dir, MAXPGPATH, "%s/pg_tblspc/%s", opt->output, - de->d_name); + snprintf(ts->new_dir, MAXPGPATH, "%s/%s/%s", opt->output, + PG_TBLSPC_DIR, de->d_name); ts->in_place = true; } diff --git a/src/bin/pg_rewind/file_ops.c b/src/bin/pg_rewind/file_ops.c index d93580bb41..762b60d3ab 100644 --- a/src/bin/pg_rewind/file_ops.c +++ b/src/bin/pg_rewind/file_ops.c @@ -448,11 +448,11 @@ recurse_dir(const char *datadir, const char *parentpath, callback(path, FILE_TYPE_SYMLINK, 0, link_target); /* - * If it's a symlink within pg_tblspc, we need to recurse into it, + * If it's a symlink within PG_TBLSPC_DIR, we need to recurse into it, * to process all the tablespaces. We also follow a symlink if * it's for pg_wal. Symlinks elsewhere are ignored. */ - if ((parentpath && strcmp(parentpath, "pg_tblspc") == 0) || + if ((parentpath && strcmp(parentpath, PG_TBLSPC_DIR) == 0) || strcmp(path, "pg_wal") == 0) recurse_dir(datadir, path, callback); } diff --git a/src/bin/pg_upgrade/exec.c b/src/bin/pg_upgrade/exec.c index 058530ab3e..78db321ace 100644 --- a/src/bin/pg_upgrade/exec.c +++ b/src/bin/pg_upgrade/exec.c @@ -350,7 +350,7 @@ check_data_dir(ClusterInfo *cluster) check_single_dir(pg_data, "global"); check_single_dir(pg_data, "pg_multixact"); check_single_dir(pg_data, "pg_subtrans"); - check_single_dir(pg_data, "pg_tblspc"); + check_single_dir(pg_data, PG_TBLSPC_DIR); check_single_dir(pg_data, "pg_twophase"); /* pg_xlog has been renamed to pg_wal in v10 */ diff --git a/src/common/file_utils.c b/src/common/file_utils.c index 6bac537a1e..c045831bbc 100644 --- a/src/common/file_utils.c +++ b/src/common/file_utils.c @@ -25,6 +25,7 @@ #include #include "common/file_utils.h" +#include "common/relpath.h" #ifdef FRONTEND #include "common/logging.h" #endif @@ -87,7 +88,7 @@ do_syncfs(const char *path) * Synchronize PGDATA and all its contents. * * We sync regular files and directories wherever they are, but we follow - * symlinks only for pg_wal (or pg_xlog) and immediately under pg_tblspc. + * symlinks only for pg_wal (or pg_xlog) and immediately under PG_TBLSPC_DIR. * Other symlinks are presumed to point at files we're not responsible for * syncing, and might not have privileges to write at all. * @@ -105,7 +106,7 @@ sync_pgdata(const char *pg_data, /* handle renaming of pg_xlog to pg_wal in post-10 clusters */ snprintf(pg_wal, MAXPGPATH, "%s/%s", pg_data, serverVersion < MINIMUM_VERSION_FOR_PG_WAL ? "pg_xlog" : "pg_wal"); - snprintf(pg_tblspc, MAXPGPATH, "%s/pg_tblspc", pg_data); + snprintf(pg_tblspc, MAXPGPATH, "%s/%s", pg_data, PG_TBLSPC_DIR); /* * If pg_wal is a symlink, we'll need to recurse into it separately, @@ -196,9 +197,9 @@ sync_pgdata(const char *pg_data, * Now we do the fsync()s in the same order. * * The main call ignores symlinks, so in addition to specially - * processing pg_wal if it's a symlink, pg_tblspc has to be + * processing pg_wal if it's a symlink, PG_TBLSPC_DIR has to be * visited separately with process_symlinks = true. Note that - * if there are any plain directories in pg_tblspc, they'll + * if there are any plain directories in PG_TBLSPC_DIR, they'll * get fsync'd twice. That's not an expected case so we don't * worry about optimizing it. */ diff --git a/src/common/relpath.c b/src/common/relpath.c index f54c36ef7a..426a0114f8 100644 --- a/src/common/relpath.c +++ b/src/common/relpath.c @@ -123,8 +123,8 @@ GetDatabasePath(Oid dbOid, Oid spcOid) else { /* All other tablespaces are accessed via symlinks */ - return psprintf("pg_tblspc/%u/%s/%u", - spcOid, TABLESPACE_VERSION_DIRECTORY, dbOid); + return psprintf("%s/%u/%s/%u", + PG_TBLSPC_DIR, spcOid, TABLESPACE_VERSION_DIRECTORY, dbOid); } } @@ -184,25 +184,25 @@ GetRelationPath(Oid dbOid, Oid spcOid, RelFileNumber relNumber, if (procNumber == INVALID_PROC_NUMBER) { if (forkNumber != MAIN_FORKNUM) - path = psprintf("pg_tblspc/%u/%s/%u/%u_%s", - spcOid, TABLESPACE_VERSION_DIRECTORY, + path = psprintf("%s/%u/%s/%u/%u_%s", + PG_TBLSPC_DIR, spcOid, TABLESPACE_VERSION_DIRECTORY, dbOid, relNumber, forkNames[forkNumber]); else - path = psprintf("pg_tblspc/%u/%s/%u/%u", - spcOid, TABLESPACE_VERSION_DIRECTORY, + path = psprintf("%s/%u/%s/%u/%u", + PG_TBLSPC_DIR, spcOid, TABLESPACE_VERSION_DIRECTORY, dbOid, relNumber); } else { if (forkNumber != MAIN_FORKNUM) - path = psprintf("pg_tblspc/%u/%s/%u/t%d_%u_%s", - spcOid, TABLESPACE_VERSION_DIRECTORY, + path = psprintf("%s/%u/%s/%u/t%d_%u_%s", + PG_TBLSPC_DIR, spcOid, TABLESPACE_VERSION_DIRECTORY, dbOid, procNumber, relNumber, forkNames[forkNumber]); else - path = psprintf("pg_tblspc/%u/%s/%u/t%d_%u", - spcOid, TABLESPACE_VERSION_DIRECTORY, + path = psprintf("%s/%u/%s/%u/t%d_%u", + PG_TBLSPC_DIR, spcOid, TABLESPACE_VERSION_DIRECTORY, dbOid, procNumber, relNumber); } } diff --git a/src/fe_utils/astreamer_file.c b/src/fe_utils/astreamer_file.c index c9a030853b..9824009873 100644 --- a/src/fe_utils/astreamer_file.c +++ b/src/fe_utils/astreamer_file.c @@ -19,6 +19,7 @@ #include "common/file_perm.h" #include "common/logging.h" +#include "common/relpath.h" #include "common/string.h" #include "fe_utils/astreamer.h" @@ -289,29 +290,31 @@ astreamer_extractor_content(astreamer *streamer, astreamer_member *member, * link before starting the actual backup. So just ignore creation failures * on related directories. * - * If in-place tablespaces are used, pg_tblspc and subdirectories may already + * If in-place tablespaces are used, PG_TBLSPC_DIR and subdirectories may already * exist when we get here. So tolerate that case, too. */ static bool should_allow_existing_directory(const char *pathname) { +#define PG_TBLSPC_DIR_CONCAT "/" PG_TBLSPC_DIR "/" const char *filename = last_dir_separator(pathname) + 1; if (strcmp(filename, "pg_wal") == 0 || strcmp(filename, "pg_xlog") == 0 || strcmp(filename, "archive_status") == 0 || strcmp(filename, "summaries") == 0 || - strcmp(filename, "pg_tblspc") == 0) + strcmp(filename, PG_TBLSPC_DIR) == 0) return true; if (strspn(filename, "0123456789") == strlen(filename)) { - const char *pg_tblspc = strstr(pathname, "/pg_tblspc/"); + const char *pg_tblspc = strstr(pathname, PG_TBLSPC_DIR_CONCAT); return pg_tblspc != NULL && pg_tblspc + 11 == filename; } return false; +#undef PG_TBLSPC_DIR_CONCAT } /* @@ -335,10 +338,10 @@ extract_directory(const char *filename, mode_t mode) /* * Create a symbolic link. * - * It's most likely a link in pg_tblspc directory, to the location of a + * It's most likely a link in PG_TBLSPC_DIR directory, to the location of a * tablespace. Apply any tablespace mapping given on the command line * (--tablespace-mapping). (We blindly apply the mapping without checking that - * the link really is inside pg_tblspc. We don't expect there to be other + * the link really is inside PG_TBLSPC_DIR. We don't expect there to be other * symlinks in a data directory, but if there are, you can call it an * undocumented feature that you can map them too.) */ diff --git a/src/include/common/relpath.h b/src/include/common/relpath.h index 6f006d5a93..a6cb091635 100644 --- a/src/include/common/relpath.h +++ b/src/include/common/relpath.h @@ -33,6 +33,10 @@ typedef Oid RelFileNumber; #define TABLESPACE_VERSION_DIRECTORY "PG_" PG_MAJORVERSION "_" \ CppAsString2(CATALOG_VERSION_NO) +#define PG_TBLSPC_DIR "pg_tblspc" +#define RELATIVE_PG_TBLSPC_DIR "./" PG_TBLSPC_DIR +#define PG_TBLSPC_DIR_SLASH PG_TBLSPC_DIR "/" + /* Characters to allow for an OID in a relation path */ #define OIDCHARS 10 /* max chars printed by %u */ -- 2.34.1