fd.h File Reference

#include <dirent.h>

Include dependency graph for fd.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	FILE_POSSIBLY_DELETED(err)   ((err) == ENOENT)
#define	PG_O_DIRECT   0
#define	PG_TEMP_FILES_DIR   "pgsql_tmp"
#define	PG_TEMP_FILE_PREFIX   "pgsql_tmp"

Typedefs
typedef enum RecoveryInitSyncMethod	RecoveryInitSyncMethod
typedef int	File

Enumerations
enum	RecoveryInitSyncMethod { RECOVERY_INIT_SYNC_METHOD_FSYNC, RECOVERY_INIT_SYNC_METHOD_SYNCFS }

Functions
File	PathNameOpenFile (const char *fileName, int fileFlags)
File	PathNameOpenFilePerm (const char *fileName, int fileFlags, mode_t fileMode)
File	OpenTemporaryFile (bool interXact)
void	FileClose (File file)
int	FilePrefetch (File file, off_t offset, int amount, uint32 wait_event_info)
int	FileRead (File file, char *buffer, int amount, off_t offset, uint32 wait_event_info)
int	FileWrite (File file, char *buffer, int amount, off_t offset, uint32 wait_event_info)
int	FileSync (File file, uint32 wait_event_info)
off_t	FileSize (File file)
int	FileTruncate (File file, off_t offset, uint32 wait_event_info)
void	FileWriteback (File file, off_t offset, off_t nbytes, uint32 wait_event_info)
char *	FilePathName (File file)
int	FileGetRawDesc (File file)
int	FileGetRawFlags (File file)
mode_t	FileGetRawMode (File file)
File	PathNameCreateTemporaryFile (const char *name, bool error_on_failure)
File	PathNameOpenTemporaryFile (const char *path, int mode)
bool	PathNameDeleteTemporaryFile (const char *name, bool error_on_failure)
void	PathNameCreateTemporaryDir (const char *base, const char *name)
void	PathNameDeleteTemporaryDir (const char *name)
void	TempTablespacePath (char *path, Oid tablespace)
FILE *	AllocateFile (const char *name, const char *mode)
int	FreeFile (FILE *file)
FILE *	OpenPipeStream (const char *command, const char *mode)
int	ClosePipeStream (FILE *file)
DIR *	AllocateDir (const char *dirname)
struct dirent *	ReadDir (DIR *dir, const char *dirname)
struct dirent *	ReadDirExtended (DIR *dir, const char *dirname, int elevel)
int	FreeDir (DIR *dir)
int	OpenTransientFile (const char *fileName, int fileFlags)
int	OpenTransientFilePerm (const char *fileName, int fileFlags, mode_t fileMode)
int	CloseTransientFile (int fd)
int	BasicOpenFile (const char *fileName, int fileFlags)
int	BasicOpenFilePerm (const char *fileName, int fileFlags, mode_t fileMode)
bool	AcquireExternalFD (void)
void	ReserveExternalFD (void)
void	ReleaseExternalFD (void)
int	MakePGDirectory (const char *directoryName)
void	InitFileAccess (void)
void	set_max_safe_fds (void)
void	closeAllVfds (void)
void	SetTempTablespaces (Oid *tableSpaces, int numSpaces)
bool	TempTablespacesAreSet (void)
int	GetTempTablespaces (Oid *tableSpaces, int numSpaces)
Oid	GetNextTempTableSpace (void)
void	AtEOXact_Files (bool isCommit)
void	AtEOSubXact_Files (bool isCommit, SubTransactionId mySubid, SubTransactionId parentSubid)
void	RemovePgTempFiles (void)
void	RemovePgTempFilesInDir (const char *tmpdirname, bool missing_ok, bool unlink_all)
bool	looks_like_temp_rel_name (const char *name)
int	pg_fsync (int fd)
int	pg_fsync_no_writethrough (int fd)
int	pg_fsync_writethrough (int fd)
int	pg_fdatasync (int fd)
void	pg_flush_data (int fd, off_t offset, off_t amount)
ssize_t	pg_pwritev_with_retry (int fd, const struct iovec *iov, int iovcnt, off_t offset)
int	pg_truncate (const char *path, off_t length)
void	fsync_fname (const char *fname, bool isdir)
int	fsync_fname_ext (const char *fname, bool isdir, bool ignore_perm, int elevel)
int	durable_rename (const char *oldfile, const char *newfile, int loglevel)
int	durable_unlink (const char *fname, int loglevel)
int	durable_rename_excl (const char *oldfile, const char *newfile, int loglevel)
void	SyncDataDirectory (void)
int	data_sync_elevel (int elevel)

Variables
PGDLLIMPORT int	max_files_per_process
PGDLLIMPORT bool	data_sync_retry
int	recovery_init_sync_method
int	max_safe_fds

Macro Definition Documentation

FILE_POSSIBLY_DELETED

#define FILE_POSSIBLY_DELETED

(

err

)

((err) == ENOENT)

Definition at line 77 of file fd.h.

Referenced by _mdfd_getseg(), mdopenfork(), and ProcessSyncRequests().

PG_O_DIRECT

#define PG_O_DIRECT   0

Definition at line 95 of file fd.h.

Referenced by BasicOpenFilePerm(), and get_sync_bit().

PG_TEMP_FILE_PREFIX

#define PG_TEMP_FILE_PREFIX   "pgsql_tmp"

Definition at line 195 of file fd.h.

PG_TEMP_FILES_DIR

#define PG_TEMP_FILES_DIR   "pgsql_tmp"

Definition at line 194 of file fd.h.

Typedef Documentation

File

typedef int File

Definition at line 54 of file fd.h.

RecoveryInitSyncMethod

typedef enum RecoveryInitSyncMethod RecoveryInitSyncMethod

Enumeration Type Documentation

RecoveryInitSyncMethod

enum RecoveryInitSyncMethod

Enumerator
RECOVERY_INIT_SYNC_METHOD_FSYNC
RECOVERY_INIT_SYNC_METHOD_SYNCFS

Definition at line 48 of file fd.h.

{
    RECOVERY_INIT_SYNC_METHOD_FSYNC,
    RECOVERY_INIT_SYNC_METHOD_SYNCFS
}           RecoveryInitSyncMethod;

Function Documentation

AcquireExternalFD()

bool AcquireExternalFD

(

void

)

Definition at line 1139 of file fd.c.

References max_safe_fds, numExternalFDs, and ReserveExternalFD().

Referenced by connect_pg_server(), CreateWaitEventSet(), dblink_connect(), and dblink_get_conn().

{
    /*
     * We don't want more than max_safe_fds / 3 FDs to be consumed for
     * "external" FDs.
     */
    if (numExternalFDs < max_safe_fds / 3)
    {
        ReserveExternalFD();
        return true;
    }
    errno = EMFILE;
    return false;
}

AllocateDir()

DIR* AllocateDir

(

const char *

dirname

)

Definition at line 2678 of file fd.c.

References AllocateDescDir, AllocateDesc::create_subid, AllocateDesc::desc, AllocateDesc::dir, DO_DB, elog, ereport, errcode(), errmsg(), ERROR, GetCurrentSubTransactionId(), AllocateDesc::kind, LOG, maxAllocatedDescs, numAllocatedDescs, opendir(), ReleaseLruFile(), ReleaseLruFiles(), and reserveAllocatedDesc().

Referenced by calculate_database_size(), calculate_tablespace_size(), CheckPointLogicalRewriteHeap(), CheckPointSnapBuild(), CleanupBackupHistory(), copydir(), db_dir_size(), DeleteAllExportedSnapshotFiles(), destroy_tablespace_directories(), directory_is_empty(), do_pg_start_backup(), dsm_cleanup_for_mmap(), extension_file_exists(), get_ext_ver_list(), getInstallationPaths(), movedb(), ParseTzFile(), perform_base_backup(), pg_available_extension_versions(), pg_available_extensions(), pg_logdir_ls_internal(), pg_ls_dir(), pg_ls_dir_files(), pg_tablespace_databases(), pg_tzenumerate_next(), pg_tzenumerate_start(), pgarch_readyXlog(), pgstat_reset_remove_files(), RelationCacheInitFileRemove(), RelationCacheInitFileRemoveInDir(), RemoveNonParentXlogFiles(), RemoveOldXlogFiles(), RemovePgTempFiles(), RemovePgTempFilesInDir(), RemovePgTempRelationFiles(), RemovePgTempRelationFilesInDbspace(), RemoveTempXlogFiles(), ReorderBufferCleanupSerializedTXNs(), ResetUnloggedRelations(), ResetUnloggedRelationsInDbspaceDir(), ResetUnloggedRelationsInTablespaceDir(), restoreTwoPhaseData(), scan_directory_ci(), sendDir(), SlruScanDirectory(), StartupReorderBuffer(), StartupReplicationSlots(), SyncDataDirectory(), UpdateLogicalMappings(), and walkdir().

{
    DIR        *dir;

    DO_DB(elog(LOG, "AllocateDir: Allocated %d (%s)",
               numAllocatedDescs, dirname));

    /* Can we allocate another non-virtual FD? */
    if (!reserveAllocatedDesc())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_RESOURCES),
                 errmsg("exceeded maxAllocatedDescs (%d) while trying to open directory \"%s\"",
                        maxAllocatedDescs, dirname)));

    /* Close excess kernel FDs. */
    ReleaseLruFiles();

TryAgain:
    if ((dir = opendir(dirname)) != NULL)
    {
        AllocateDesc *desc = &allocatedDescs[numAllocatedDescs];

        desc->kind = AllocateDescDir;
        desc->desc.dir = dir;
        desc->create_subid = GetCurrentSubTransactionId();
        numAllocatedDescs++;
        return desc->desc.dir;
    }

    if (errno == EMFILE || errno == ENFILE)
    {
        int         save_errno = errno;

        ereport(LOG,
                (errcode(ERRCODE_INSUFFICIENT_RESOURCES),
                 errmsg("out of file descriptors: %m; release and retry")));
        errno = 0;
        if (ReleaseLruFile())
            goto TryAgain;
        errno = save_errno;
    }

    return NULL;
}

AllocateFile()

FILE* AllocateFile	(	const char *	name,
		const char *	mode
	)

Definition at line 2417 of file fd.c.

References AllocateDescFile, AllocateDesc::create_subid, AllocateDesc::desc, DO_DB, elog, ereport, errcode(), errmsg(), ERROR, AllocateDesc::file, GetCurrentSubTransactionId(), AllocateDesc::kind, LOG, maxAllocatedDescs, numAllocatedDescs, ReleaseLruFile(), ReleaseLruFiles(), and reserveAllocatedDesc().

Referenced by _ShowOption(), AlterSystemSetConfigFile(), apw_dump_now(), apw_load_buffers(), BackendRun(), BeginCopyFrom(), BeginCopyTo(), checkControlFile(), do_pg_start_backup(), do_pg_stop_backup(), entry_reset(), existsTimeLineHistory(), ExportSnapshot(), fill_hba_view(), gc_qtexts(), ImportSnapshot(), load_dh_file(), load_hba(), load_ident(), load_relcache_init_file(), parse_extension_control_file(), ParseTzFile(), pg_backup_start_time(), pg_current_logfile(), pg_file_write_internal(), pg_promote(), PGSharedMemoryAttach(), pgss_shmem_shutdown(), pgss_shmem_startup(), pgstat_read_db_statsfile(), pgstat_read_db_statsfile_timestamp(), pgstat_read_statsfiles(), pgstat_write_db_statsfile(), pgstat_write_statsfiles(), PostmasterMarkPIDForWorkerNotify(), read_backup_label(), read_binary_file(), read_tablespace_map(), read_whole_file(), readTimeLineHistory(), tokenize_inc_file(), tsearch_readline_begin(), ValidatePgVersion(), write_relcache_init_file(), XLogArchiveForceDone(), and XLogArchiveNotify().

{
    FILE       *file;

    DO_DB(elog(LOG, "AllocateFile: Allocated %d (%s)",
               numAllocatedDescs, name));

    /* Can we allocate another non-virtual FD? */
    if (!reserveAllocatedDesc())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_RESOURCES),
                 errmsg("exceeded maxAllocatedDescs (%d) while trying to open file \"%s\"",
                        maxAllocatedDescs, name)));

    /* Close excess kernel FDs. */
    ReleaseLruFiles();

TryAgain:
    if ((file = fopen(name, mode)) != NULL)
    {
        AllocateDesc *desc = &allocatedDescs[numAllocatedDescs];

        desc->kind = AllocateDescFile;
        desc->desc.file = file;
        desc->create_subid = GetCurrentSubTransactionId();
        numAllocatedDescs++;
        return desc->desc.file;
    }

    if (errno == EMFILE || errno == ENFILE)
    {
        int         save_errno = errno;

        ereport(LOG,
                (errcode(ERRCODE_INSUFFICIENT_RESOURCES),
                 errmsg("out of file descriptors: %m; release and retry")));
        errno = 0;
        if (ReleaseLruFile())
            goto TryAgain;
        errno = save_errno;
    }

    return NULL;
}

AtEOSubXact_Files()

void AtEOSubXact_Files	(	bool	isCommit,
		SubTransactionId	mySubid,
		SubTransactionId	parentSubid
	)

Definition at line 2966 of file fd.c.

References AllocateDesc::create_subid, FreeDesc(), i, and numAllocatedDescs.

Referenced by AbortSubTransaction(), and CommitSubTransaction().

{
    Index       i;

    for (i = 0; i < numAllocatedDescs; i++)
    {
        if (allocatedDescs[i].create_subid == mySubid)
        {
            if (isCommit)
                allocatedDescs[i].create_subid = parentSubid;
            else
            {
                /* have to recheck the item after FreeDesc (ugly) */
                FreeDesc(&allocatedDescs[i--]);
            }
        }
    }
}

AtEOXact_Files()

void AtEOXact_Files

(

bool

isCommit

)

Definition at line 2999 of file fd.c.

References CleanupTempFiles(), numTempTableSpaces, and tempTableSpaces.

Referenced by AbortTransaction(), AutoVacLauncherMain(), BackgroundWriterMain(), CheckpointerMain(), CommitTransaction(), PrepareTransaction(), and WalWriterMain().

{
    CleanupTempFiles(isCommit, false);
    tempTableSpaces = NULL;
    numTempTableSpaces = -1;
}

BasicOpenFile()

int BasicOpenFile	(	const char *	fileName,
		int	fileFlags
	)

Definition at line 1033 of file fd.c.

References BasicOpenFilePerm(), and pg_file_create_mode.

Referenced by AlterSystemSetConfigFile(), ReadControlFile(), update_controlfile(), wal_segment_open(), WalSndSegmentOpen(), WriteControlFile(), XLogFileInit(), XLogFileInitInternal(), XLogFileOpen(), and XLogFileRead().

{
    return BasicOpenFilePerm(fileName, fileFlags, pg_file_create_mode);
}

BasicOpenFilePerm()

int BasicOpenFilePerm	(	const char *	fileName,
		int	fileFlags,
		mode_t	fileMode
	)

Definition at line 1055 of file fd.c.

References close, ereport, errcode(), errmsg(), vfd::fd, LOG, O_DSYNC, PG_O_DIRECT, ReleaseLruFile(), and StaticAssertStmt.

Referenced by BasicOpenFile(), LruInsert(), OpenTransientFilePerm(), PathNameOpenFilePerm(), and readRecoverySignalFile().

{
    int         fd;

tryAgain:
#ifdef PG_O_DIRECT_USE_F_NOCACHE

    /*
     * The value we defined to stand in for O_DIRECT when simulating it with
     * F_NOCACHE had better not collide with any of the standard flags.
     */
    StaticAssertStmt((PG_O_DIRECT &
                      (O_APPEND |
                       O_CREAT |
                       O_EXCL |
                       O_RDWR |
                       O_RDONLY |
                       O_SYNC |
                       O_TRUNC |
                       O_WRONLY)) == 0,
                     "PG_O_DIRECT value collides with standard flag");
#if defined(O_CLOEXEC)
    StaticAssertStmt((PG_O_DIRECT & O_CLOEXEC) == 0,
                     "PG_O_DIRECT value collides with O_CLOEXEC");
#endif
#if defined(O_DSYNC)
    StaticAssertStmt((PG_O_DIRECT & O_DSYNC) == 0,
                     "PG_O_DIRECT value collides with O_DSYNC");
#endif

    fd = open(fileName, fileFlags & ~PG_O_DIRECT, fileMode);
#else
    fd = open(fileName, fileFlags, fileMode);
#endif

    if (fd >= 0)
    {
#ifdef PG_O_DIRECT_USE_F_NOCACHE
        if (fileFlags & PG_O_DIRECT)
        {
            if (fcntl(fd, F_NOCACHE, 1) < 0)
            {
                int         save_errno = errno;

                close(fd);
                errno = save_errno;
                return -1;
            }
        }
#endif

        return fd;              /* success! */
    }

    if (errno == EMFILE || errno == ENFILE)
    {
        int         save_errno = errno;

        ereport(LOG,
                (errcode(ERRCODE_INSUFFICIENT_RESOURCES),
                 errmsg("out of file descriptors: %m; release and retry")));
        errno = 0;
        if (ReleaseLruFile())
            goto tryAgain;
        errno = save_errno;
    }

    return -1;                  /* failure */
}

closeAllVfds()

void closeAllVfds

(

void

)

Definition at line 2855 of file fd.c.

References Assert, FileIsNotOpen, i, LruDelete(), and SizeVfdCache.

Referenced by standard_ProcessUtility().

{
    Index       i;

    if (SizeVfdCache > 0)
    {
        Assert(FileIsNotOpen(0));   /* Make sure ring not corrupted */
        for (i = 1; i < SizeVfdCache; i++)
        {
            if (!FileIsNotOpen(i))
                LruDelete(i);
        }
    }
}

ClosePipeStream()

int ClosePipeStream

(

FILE *

file

)

Definition at line 2826 of file fd.c.

References AllocateDescPipe, AllocateDesc::desc, DO_DB, elog, AllocateDesc::file, FreeDesc(), i, AllocateDesc::kind, LOG, numAllocatedDescs, and WARNING.

Referenced by ClosePipeFromProgram(), ClosePipeToProgram(), pg_import_system_collations(), and run_ssl_passphrase_command().

{
    int         i;

    DO_DB(elog(LOG, "ClosePipeStream: Allocated %d", numAllocatedDescs));

    /* Remove file from list of allocated files, if it's present */
    for (i = numAllocatedDescs; --i >= 0;)
    {
        AllocateDesc *desc = &allocatedDescs[i];

        if (desc->kind == AllocateDescPipe && desc->desc.file == file)
            return FreeDesc(desc);
    }

    /* Only get here if someone passes us a file not in allocatedDescs */
    elog(WARNING, "file passed to ClosePipeStream was not obtained from OpenPipeStream");

    return pclose(file);
}

CloseTransientFile()

int CloseTransientFile

(

int

fd

)

Definition at line 2644 of file fd.c.

References AllocateDescRawFD, close, AllocateDesc::desc, DO_DB, elog, AllocateDesc::fd, FreeDesc(), i, AllocateDesc::kind, LOG, numAllocatedDescs, and WARNING.

Referenced by ApplyLogicalMappingFile(), be_lo_export(), CheckPointLogicalRewriteHeap(), CheckPointReplicationOrigin(), copy_file(), dsm_impl_mmap(), durable_rename(), fsync_fname_ext(), get_controlfile(), heap_xlog_logical_rewrite(), lo_import_internal(), load_relmap_file(), looks_like_temp_rel_name(), perform_base_backup(), pg_truncate(), qtext_load_file(), qtext_store(), ReadTwoPhaseFile(), RecreateTwoPhaseFile(), ReorderBufferSerializeChange(), ReorderBufferSerializeTXN(), RestoreSlotFromDisk(), SaveSlotToPath(), sendFile(), SendTimeLineHistory(), SimpleLruDoesPhysicalPageExist(), SimpleLruWriteAll(), SlruInternalWritePage(), SlruPhysicalReadPage(), SlruPhysicalWritePage(), SlruSyncFileTag(), SnapBuildRestore(), SnapBuildSerialize(), StartupReplicationOrigin(), walkdir(), write_relmap_file(), writeTimeLineHistory(), writeTimeLineHistoryFile(), and XLogFileCopy().

{
    int         i;

    DO_DB(elog(LOG, "CloseTransientFile: Allocated %d", numAllocatedDescs));

    /* Remove fd from list of allocated files, if it's present */
    for (i = numAllocatedDescs; --i >= 0;)
    {
        AllocateDesc *desc = &allocatedDescs[i];

        if (desc->kind == AllocateDescRawFD && desc->desc.fd == fd)
            return FreeDesc(desc);
    }

    /* Only get here if someone passes us a file not in allocatedDescs */
    elog(WARNING, "fd passed to CloseTransientFile was not obtained from OpenTransientFile");

    return close(fd);
}

data_sync_elevel()

int data_sync_elevel

(

int

elevel

)

Definition at line 3758 of file fd.c.

References data_sync_retry, elevel, and PANIC.

Referenced by CheckPointLogicalRewriteHeap(), FileClose(), fsync_fname(), heap_xlog_logical_rewrite(), logical_end_heap_rewrite(), LruDelete(), mdimmedsync(), pg_flush_data(), ProcessSyncRequests(), register_dirty_segment(), SlruReportIOError(), write_relmap_file(), writeTimeLineHistory(), writeTimeLineHistoryFile(), and XLogFileCopy().

{
    return data_sync_retry ? elevel : PANIC;
}

durable_rename()

int durable_rename	(	const char *	oldfile,
		const char *	newfile,
		int	loglevel
	)

Definition at line 692 of file fd.c.

References CloseTransientFile(), ereport, errcode_for_file_access(), errmsg(), vfd::fd, fsync_fname_ext(), fsync_parent_path(), OpenTransientFile(), PG_BINARY, and pg_fsync().

Referenced by AlterSystemSetConfigFile(), apw_dump_now(), BaseBackup(), CancelBackup(), CheckPointReplicationOrigin(), dir_close(), KeepFileRestoredFromArchive(), pgarch_archiveDone(), pgss_shmem_shutdown(), StartupXLOG(), and XLogArchiveForceDone().

{
    int         fd;

    /*
     * First fsync the old and target path (if it exists), to ensure that they
     * are properly persistent on disk. Syncing the target file is not
     * strictly necessary, but it makes it easier to reason about crashes;
     * because it's then guaranteed that either source or target file exists
     * after a crash.
     */
    if (fsync_fname_ext(oldfile, false, false, elevel) != 0)
        return -1;

    fd = OpenTransientFile(newfile, PG_BINARY | O_RDWR);
    if (fd < 0)
    {
        if (errno != ENOENT)
        {
            ereport(elevel,
                    (errcode_for_file_access(),
                     errmsg("could not open file \"%s\": %m", newfile)));
            return -1;
        }
    }
    else
    {
        if (pg_fsync(fd) != 0)
        {
            int         save_errno;

            /* close file upon error, might not be in transaction context */
            save_errno = errno;
            CloseTransientFile(fd);
            errno = save_errno;

            ereport(elevel,
                    (errcode_for_file_access(),
                     errmsg("could not fsync file \"%s\": %m", newfile)));
            return -1;
        }

        if (CloseTransientFile(fd) != 0)
        {
            ereport(elevel,
                    (errcode_for_file_access(),
                     errmsg("could not close file \"%s\": %m", newfile)));
            return -1;
        }
    }

    /* Time to do the real deal... */
    if (rename(oldfile, newfile) < 0)
    {
        ereport(elevel,
                (errcode_for_file_access(),
                 errmsg("could not rename file \"%s\" to \"%s\": %m",
                        oldfile, newfile)));
        return -1;
    }

    /*
     * To guarantee renaming the file is persistent, fsync the file with its
     * new name, and its containing directory.
     */
    if (fsync_fname_ext(newfile, false, false, elevel) != 0)
        return -1;

    if (fsync_parent_path(newfile, elevel) != 0)
        return -1;

    return 0;
}

durable_rename_excl()

int durable_rename_excl	(	const char *	oldfile,
		const char *	newfile,
		int	loglevel
	)

Definition at line 822 of file fd.c.

References ereport, errcode_for_file_access(), errmsg(), fsync_fname_ext(), fsync_parent_path(), and link().

Referenced by InstallXLogFileSegment(), writeTimeLineHistory(), and writeTimeLineHistoryFile().

{
    /*
     * Ensure that, if we crash directly after the rename/link, a file with
     * valid contents is moved into place.
     */
    if (fsync_fname_ext(oldfile, false, false, elevel) != 0)
        return -1;

#ifdef HAVE_WORKING_LINK
    if (link(oldfile, newfile) < 0)
    {
        ereport(elevel,
                (errcode_for_file_access(),
                 errmsg("could not link file \"%s\" to \"%s\": %m",
                        oldfile, newfile)));
        return -1;
    }
    unlink(oldfile);
#else
    if (rename(oldfile, newfile) < 0)
    {
        ereport(elevel,
                (errcode_for_file_access(),
                 errmsg("could not rename file \"%s\" to \"%s\": %m",
                        oldfile, newfile)));
        return -1;
    }
#endif

    /*
     * Make change persistent in case of an OS crash, both the new entry and
     * its parent directory need to be flushed.
     */
    if (fsync_fname_ext(newfile, false, false, elevel) != 0)
        return -1;

    /* Same for parent directory */
    if (fsync_parent_path(newfile, elevel) != 0)
        return -1;

    return 0;
}

durable_unlink()

int durable_unlink	(	const char *	fname,
		int	loglevel
	)

Definition at line 782 of file fd.c.

References ereport, errcode_for_file_access(), errmsg(), and fsync_parent_path().

Referenced by do_pg_stop_backup(), exitArchiveRecovery(), InstallXLogFileSegment(), and RemoveXlogFile().

{
    if (unlink(fname) < 0)
    {
        ereport(elevel,
                (errcode_for_file_access(),
                 errmsg("could not remove file \"%s\": %m",
                        fname)));
        return -1;
    }

    /*
     * To guarantee that the removal of the file is persistent, fsync its
     * parent directory.
     */
    if (fsync_parent_path(fname, elevel) != 0)
        return -1;

    return 0;
}

FileClose()

void FileClose

(

File

file

)

Definition at line 1917 of file fd.c.

References Assert, close, data_sync_elevel(), Delete(), DO_DB, elog, ereport, errcode_for_file_access(), errmsg(), vfd::fd, FD_DELETE_AT_CLOSE, FD_TEMP_FILE_LIMIT, vfd::fdstate, FileIsNotOpen, FileIsValid, vfd::fileName, vfd::fileSize, FreeVfd(), LOG, nfile, ReportTemporaryFileUsage(), ResourceOwnerForgetFile(), vfd::resowner, stat::st_size, stat, temporary_files_size, and VFD_CLOSED.

Referenced by BufFileClose(), BufFileTruncateShared(), CleanupTempFiles(), logical_end_heap_rewrite(), mdclose(), mdimmedsync(), mdsyncfiletag(), mdtruncate(), ReorderBufferIterTXNFinish(), ReorderBufferRestoreChanges(), and ResourceOwnerReleaseInternal().

{
    Vfd        *vfdP;

    Assert(FileIsValid(file));

    DO_DB(elog(LOG, "FileClose: %d (%s)",
               file, VfdCache[file].fileName));

    vfdP = &VfdCache[file];

    if (!FileIsNotOpen(file))
    {
        /* close the file */
        if (close(vfdP->fd) != 0)
        {
            /*
             * We may need to panic on failure to close non-temporary files;
             * see LruDelete.
             */
            elog(vfdP->fdstate & FD_TEMP_FILE_LIMIT ? LOG : data_sync_elevel(LOG),
                 "could not close file \"%s\": %m", vfdP->fileName);
        }

        --nfile;
        vfdP->fd = VFD_CLOSED;

        /* remove the file from the lru ring */
        Delete(file);
    }

    if (vfdP->fdstate & FD_TEMP_FILE_LIMIT)
    {
        /* Subtract its size from current usage (do first in case of error) */
        temporary_files_size -= vfdP->fileSize;
        vfdP->fileSize = 0;
    }

    /*
     * Delete the file if it was temporary, and make a log entry if wanted
     */
    if (vfdP->fdstate & FD_DELETE_AT_CLOSE)
    {
        struct stat filestats;
        int         stat_errno;

        /*
         * If we get an error, as could happen within the ereport/elog calls,
         * we'll come right back here during transaction abort.  Reset the
         * flag to ensure that we can't get into an infinite loop.  This code
         * is arranged to ensure that the worst-case consequence is failing to
         * emit log message(s), not failing to attempt the unlink.
         */
        vfdP->fdstate &= ~FD_DELETE_AT_CLOSE;


        /* first try the stat() */
        if (stat(vfdP->fileName, &filestats))
            stat_errno = errno;
        else
            stat_errno = 0;

        /* in any case do the unlink */
        if (unlink(vfdP->fileName))
            ereport(LOG,
                    (errcode_for_file_access(),
                     errmsg("could not delete file \"%s\": %m", vfdP->fileName)));

        /* and last report the stat results */
        if (stat_errno == 0)
            ReportTemporaryFileUsage(vfdP->fileName, filestats.st_size);
        else
        {
            errno = stat_errno;
            ereport(LOG,
                    (errcode_for_file_access(),
                     errmsg("could not stat file \"%s\": %m", vfdP->fileName)));
        }
    }

    /* Unregister it from the resource owner */
    if (vfdP->resowner)
        ResourceOwnerForgetFile(vfdP->resowner, file);

    /*
     * Return the Vfd slot to the free list
     */
    FreeVfd(file);
}

FileGetRawDesc()

int FileGetRawDesc

(

File

file

)

Definition at line 2311 of file fd.c.

References Assert, vfd::fd, and FileIsValid.

{
    Assert(FileIsValid(file));
    return VfdCache[file].fd;
}

FileGetRawFlags()

int FileGetRawFlags

(

File

file

)

Definition at line 2321 of file fd.c.

References Assert, vfd::fileFlags, and FileIsValid.

{
    Assert(FileIsValid(file));
    return VfdCache[file].fileFlags;
}

FileGetRawMode()

mode_t FileGetRawMode

(

File

file

)

Definition at line 2331 of file fd.c.

References Assert, FileIsValid, and vfd::fileMode.

{
    Assert(FileIsValid(file));
    return VfdCache[file].fileMode;
}

FilePathName()

char* FilePathName

(

File

file

)

Definition at line 2295 of file fd.c.

References Assert, FileIsValid, and vfd::fileName.

Referenced by _mdnblocks(), BufFileDumpBuffer(), BufFileLoadBuffer(), BufFileSeek(), BufFileSize(), BufFileTruncateShared(), mdextend(), mdimmedsync(), mdread(), mdsyncfiletag(), mdtruncate(), mdwrite(), and register_dirty_segment().

{
    Assert(FileIsValid(file));

    return VfdCache[file].fileName;
}

FilePrefetch()

int FilePrefetch	(	File	file,
		off_t	offset,
		int	amount,
		uint32	wait_event_info
	)

Definition at line 2017 of file fd.c.

References Assert, DO_DB, elog, vfd::fd, FileAccess(), FileIsValid, vfd::fileName, INT64_FORMAT, LOG, pgstat_report_wait_end(), and pgstat_report_wait_start().

Referenced by mdprefetch().

{
#if defined(USE_POSIX_FADVISE) && defined(POSIX_FADV_WILLNEED)
    int         returnCode;

    Assert(FileIsValid(file));

    DO_DB(elog(LOG, "FilePrefetch: %d (%s) " INT64_FORMAT " %d",
               file, VfdCache[file].fileName,
               (int64) offset, amount));

    returnCode = FileAccess(file);
    if (returnCode < 0)
        return returnCode;

    pgstat_report_wait_start(wait_event_info);
    returnCode = posix_fadvise(VfdCache[file].fd, offset, amount,
                               POSIX_FADV_WILLNEED);
    pgstat_report_wait_end();

    return returnCode;
#else
    Assert(FileIsValid(file));
    return 0;
#endif
}

FileRead()

int FileRead	(	File	file,
		char *	buffer,
		int	amount,
		off_t	offset,
		uint32	wait_event_info
	)

Definition at line 2068 of file fd.c.

References _dosmaperr(), Assert, DO_DB, EINTR, elog, error(), vfd::fd, FileAccess(), FileIsValid, vfd::fileName, INT64_FORMAT, LOG, pg_pread(), pg_usleep(), pgstat_report_wait_end(), and pgstat_report_wait_start().

Referenced by BufFileLoadBuffer(), mdread(), and ReorderBufferRestoreChanges().

{
    int         returnCode;
    Vfd        *vfdP;

    Assert(FileIsValid(file));

    DO_DB(elog(LOG, "FileRead: %d (%s) " INT64_FORMAT " %d %p",
               file, VfdCache[file].fileName,
               (int64) offset,
               amount, buffer));

    returnCode = FileAccess(file);
    if (returnCode < 0)
        return returnCode;

    vfdP = &VfdCache[file];

retry:
    pgstat_report_wait_start(wait_event_info);
    returnCode = pg_pread(vfdP->fd, buffer, amount, offset);
    pgstat_report_wait_end();

    if (returnCode < 0)
    {
        /*
         * Windows may run out of kernel buffers and return "Insufficient
         * system resources" error.  Wait a bit and retry to solve it.
         *
         * It is rumored that EINTR is also possible on some Unix filesystems,
         * in which case immediate retry is indicated.
         */
#ifdef WIN32
        DWORD       error = GetLastError();

        switch (error)
        {
            case ERROR_NO_SYSTEM_RESOURCES:
                pg_usleep(1000L);
                errno = EINTR;
                break;
            default:
                _dosmaperr(error);
                break;
        }
#endif
        /* OK to retry if interrupted */
        if (errno == EINTR)
            goto retry;
    }

    return returnCode;
}

FileSize()

off_t FileSize

(

File

file

)

Definition at line 2243 of file fd.c.

References Assert, DO_DB, elog, vfd::fd, FileAccess(), FileIsNotOpen, FileIsValid, vfd::fileName, and LOG.

Referenced by _mdnblocks(), BufFileSeek(), and BufFileSize().

{
    Assert(FileIsValid(file));

    DO_DB(elog(LOG, "FileSize %d (%s)",
               file, VfdCache[file].fileName));

    if (FileIsNotOpen(file))
    {
        if (FileAccess(file) < 0)
            return (off_t) -1;
    }

    return lseek(VfdCache[file].fd, 0, SEEK_END);
}

FileSync()

int FileSync	(	File	file,
		uint32	wait_event_info
	)

Definition at line 2222 of file fd.c.

References Assert, DO_DB, elog, vfd::fd, FileAccess(), FileIsValid, vfd::fileName, LOG, pg_fsync(), pgstat_report_wait_end(), and pgstat_report_wait_start().

Referenced by logical_end_heap_rewrite(), mdimmedsync(), mdsyncfiletag(), and register_dirty_segment().

{
    int         returnCode;

    Assert(FileIsValid(file));

    DO_DB(elog(LOG, "FileSync: %d (%s)",
               file, VfdCache[file].fileName));

    returnCode = FileAccess(file);
    if (returnCode < 0)
        return returnCode;

    pgstat_report_wait_start(wait_event_info);
    returnCode = pg_fsync(VfdCache[file].fd);
    pgstat_report_wait_end();

    return returnCode;
}

FileTruncate()

int FileTruncate	(	File	file,
		off_t	offset,
		uint32	wait_event_info
	)

Definition at line 2260 of file fd.c.

References Assert, DO_DB, elog, vfd::fd, FD_TEMP_FILE_LIMIT, vfd::fdstate, FileAccess(), FileIsValid, vfd::fileName, vfd::fileSize, ftruncate, LOG, pgstat_report_wait_end(), pgstat_report_wait_start(), and temporary_files_size.

Referenced by BufFileTruncateShared(), and mdtruncate().

{
    int         returnCode;

    Assert(FileIsValid(file));

    DO_DB(elog(LOG, "FileTruncate %d (%s)",
               file, VfdCache[file].fileName));

    returnCode = FileAccess(file);
    if (returnCode < 0)
        return returnCode;

    pgstat_report_wait_start(wait_event_info);
    returnCode = ftruncate(VfdCache[file].fd, offset);
    pgstat_report_wait_end();

    if (returnCode == 0 && VfdCache[file].fileSize > offset)
    {
        /* adjust our state for truncation of a temp file */
        Assert(VfdCache[file].fdstate & FD_TEMP_FILE_LIMIT);
        temporary_files_size -= VfdCache[file].fileSize - offset;
        VfdCache[file].fileSize = offset;
    }

    return returnCode;
}

FileWrite()

int FileWrite	(	File	file,
		char *	buffer,
		int	amount,
		off_t	offset,
		uint32	wait_event_info
	)

Definition at line 2124 of file fd.c.

References _dosmaperr(), Assert, DO_DB, EINTR, elog, ereport, errcode(), errmsg(), ERROR, error(), vfd::fd, FD_TEMP_FILE_LIMIT, vfd::fdstate, FileAccess(), FileIsValid, vfd::fileName, vfd::fileSize, INT64_FORMAT, LOG, pg_pwrite(), pg_usleep(), pgstat_report_wait_end(), pgstat_report_wait_start(), temp_file_limit, and temporary_files_size.

Referenced by BufFileDumpBuffer(), logical_heap_rewrite_flush_mappings(), mdextend(), and mdwrite().

{
    int         returnCode;
    Vfd        *vfdP;

    Assert(FileIsValid(file));

    DO_DB(elog(LOG, "FileWrite: %d (%s) " INT64_FORMAT " %d %p",
               file, VfdCache[file].fileName,
               (int64) offset,
               amount, buffer));

    returnCode = FileAccess(file);
    if (returnCode < 0)
        return returnCode;

    vfdP = &VfdCache[file];

    /*
     * If enforcing temp_file_limit and it's a temp file, check to see if the
     * write would overrun temp_file_limit, and throw error if so.  Note: it's
     * really a modularity violation to throw error here; we should set errno
     * and return -1.  However, there's no way to report a suitable error
     * message if we do that.  All current callers would just throw error
     * immediately anyway, so this is safe at present.
     */
    if (temp_file_limit >= 0 && (vfdP->fdstate & FD_TEMP_FILE_LIMIT))
    {
        off_t       past_write = offset + amount;

        if (past_write > vfdP->fileSize)
        {
            uint64      newTotal = temporary_files_size;

            newTotal += past_write - vfdP->fileSize;
            if (newTotal > (uint64) temp_file_limit * (uint64) 1024)
                ereport(ERROR,
                        (errcode(ERRCODE_CONFIGURATION_LIMIT_EXCEEDED),
                         errmsg("temporary file size exceeds temp_file_limit (%dkB)",
                                temp_file_limit)));
        }
    }

retry:
    errno = 0;
    pgstat_report_wait_start(wait_event_info);
    returnCode = pg_pwrite(VfdCache[file].fd, buffer, amount, offset);
    pgstat_report_wait_end();

    /* if write didn't set errno, assume problem is no disk space */
    if (returnCode != amount && errno == 0)
        errno = ENOSPC;

    if (returnCode >= 0)
    {
        /*
         * Maintain fileSize and temporary_files_size if it's a temp file.
         */
        if (vfdP->fdstate & FD_TEMP_FILE_LIMIT)
        {
            off_t       past_write = offset + amount;

            if (past_write > vfdP->fileSize)
            {
                temporary_files_size += past_write - vfdP->fileSize;
                vfdP->fileSize = past_write;
            }
        }
    }
    else
    {
        /*
         * See comments in FileRead()
         */
#ifdef WIN32
        DWORD       error = GetLastError();

        switch (error)
        {
            case ERROR_NO_SYSTEM_RESOURCES:
                pg_usleep(1000L);
                errno = EINTR;
                break;
            default:
                _dosmaperr(error);
                break;
        }
#endif
        /* OK to retry if interrupted */
        if (errno == EINTR)
            goto retry;
    }

    return returnCode;
}

FileWriteback()

void FileWriteback	(	File	file,
		off_t	offset,
		off_t	nbytes,
		uint32	wait_event_info
	)

Definition at line 2045 of file fd.c.

References Assert, DO_DB, elog, vfd::fd, FileAccess(), FileIsValid, vfd::fileName, INT64_FORMAT, LOG, pg_flush_data(), pgstat_report_wait_end(), and pgstat_report_wait_start().

Referenced by mdwriteback().

{
    int         returnCode;

    Assert(FileIsValid(file));

    DO_DB(elog(LOG, "FileWriteback: %d (%s) " INT64_FORMAT " " INT64_FORMAT,
               file, VfdCache[file].fileName,
               (int64) offset, (int64) nbytes));

    if (nbytes <= 0)
        return;

    returnCode = FileAccess(file);
    if (returnCode < 0)
        return;

    pgstat_report_wait_start(wait_event_info);
    pg_flush_data(VfdCache[file].fd, offset, nbytes);
    pgstat_report_wait_end();
}

FreeDir()

int FreeDir

(

DIR *

dir

)

Definition at line 2796 of file fd.c.

References AllocateDescDir, closedir(), AllocateDesc::desc, AllocateDesc::dir, DO_DB, elog, FreeDesc(), i, AllocateDesc::kind, LOG, numAllocatedDescs, and WARNING.

Referenced by calculate_database_size(), calculate_tablespace_size(), CheckPointLogicalRewriteHeap(), CheckPointSnapBuild(), CleanupBackupHistory(), copydir(), db_dir_size(), DeleteAllExportedSnapshotFiles(), destroy_tablespace_directories(), directory_is_empty(), do_pg_start_backup(), dsm_cleanup_for_mmap(), extension_file_exists(), get_ext_ver_list(), getInstallationPaths(), movedb(), ParseTzFile(), perform_base_backup(), pg_available_extension_versions(), pg_available_extensions(), pg_logdir_ls_internal(), pg_ls_dir(), pg_ls_dir_files(), pg_tablespace_databases(), pg_tzenumerate_end(), pg_tzenumerate_next(), pgarch_readyXlog(), pgstat_reset_remove_files(), RelationCacheInitFileRemove(), RelationCacheInitFileRemoveInDir(), RemoveNonParentXlogFiles(), RemoveOldXlogFiles(), RemovePgTempFiles(), RemovePgTempFilesInDir(), RemovePgTempRelationFiles(), RemovePgTempRelationFilesInDbspace(), RemoveTempXlogFiles(), ReorderBufferCleanupSerializedTXNs(), ResetUnloggedRelations(), ResetUnloggedRelationsInDbspaceDir(), ResetUnloggedRelationsInTablespaceDir(), restoreTwoPhaseData(), scan_directory_ci(), sendDir(), SlruScanDirectory(), StartupReorderBuffer(), StartupReplicationSlots(), SyncDataDirectory(), UpdateLogicalMappings(), and walkdir().

{
    int         i;

    /* Nothing to do if AllocateDir failed */
    if (dir == NULL)
        return 0;

    DO_DB(elog(LOG, "FreeDir: Allocated %d", numAllocatedDescs));

    /* Remove dir from list of allocated dirs, if it's present */
    for (i = numAllocatedDescs; --i >= 0;)
    {
        AllocateDesc *desc = &allocatedDescs[i];

        if (desc->kind == AllocateDescDir && desc->desc.dir == dir)
            return FreeDesc(desc);
    }

    /* Only get here if someone passes us a dir not in allocatedDescs */
    elog(WARNING, "dir passed to FreeDir was not obtained from AllocateDir");

    return closedir(dir);
}

FreeFile()

int FreeFile

(

FILE *

file

)

Definition at line 2616 of file fd.c.

References AllocateDescFile, AllocateDesc::desc, DO_DB, elog, AllocateDesc::file, FreeDesc(), i, AllocateDesc::kind, LOG, numAllocatedDescs, and WARNING.

Referenced by _ShowOption(), AlterSystemSetConfigFile(), apw_dump_now(), apw_load_buffers(), BackendRun(), checkControlFile(), do_pg_start_backup(), do_pg_stop_backup(), EndCopy(), EndCopyFrom(), entry_reset(), existsTimeLineHistory(), ExportSnapshot(), fill_hba_view(), gc_qtexts(), ImportSnapshot(), load_dh_file(), load_hba(), load_ident(), load_relcache_init_file(), parse_extension_control_file(), ParseTzFile(), pg_backup_start_time(), pg_current_logfile(), pg_file_write_internal(), pg_promote(), PGSharedMemoryAttach(), pgss_shmem_shutdown(), pgss_shmem_startup(), pgstat_read_db_statsfile(), pgstat_read_db_statsfile_timestamp(), pgstat_read_statsfiles(), pgstat_write_db_statsfile(), pgstat_write_statsfiles(), PostmasterMarkPIDForWorkerNotify(), read_backup_label(), read_binary_file(), read_tablespace_map(), read_whole_file(), readTimeLineHistory(), tokenize_inc_file(), tsearch_readline_end(), ValidatePgVersion(), write_relcache_init_file(), XLogArchiveForceDone(), and XLogArchiveNotify().

{
    int         i;

    DO_DB(elog(LOG, "FreeFile: Allocated %d", numAllocatedDescs));

    /* Remove file from list of allocated files, if it's present */
    for (i = numAllocatedDescs; --i >= 0;)
    {
        AllocateDesc *desc = &allocatedDescs[i];

        if (desc->kind == AllocateDescFile && desc->desc.file == file)
            return FreeDesc(desc);
    }

    /* Only get here if someone passes us a file not in allocatedDescs */
    elog(WARNING, "file passed to FreeFile was not obtained from AllocateFile");

    return fclose(file);
}

fsync_fname()

void fsync_fname	(	const char *	fname,
		bool	isdir
	)

Definition at line 666 of file fd.c.

References data_sync_elevel(), ERROR, and fsync_fname_ext().

Referenced by _CloseArchive(), CheckPointTwoPhase(), copydir(), CreateSlotOnDisk(), dir_close(), dir_finish(), dir_open_for_write(), main(), ReplicationSlotDropPtr(), ResetUnloggedRelationsInDbspaceDir(), RestoreSlotFromDisk(), SaveSlotToPath(), SimpleLruWriteAll(), SnapBuildRestore(), SnapBuildSerialize(), StartupReplicationSlots(), and tar_finish().

{
    fsync_fname_ext(fname, isdir, false, data_sync_elevel(ERROR));
}

fsync_fname_ext()

int fsync_fname_ext	(	const char *	fname,
		bool	isdir,
		bool	ignore_perm,
		int	elevel
	)

Definition at line 3619 of file fd.c.

References CloseTransientFile(), ereport, errcode_for_file_access(), errmsg(), vfd::fd, OpenTransientFile(), PG_BINARY, and pg_fsync().

Referenced by datadir_fsync_fname(), durable_rename(), durable_rename_excl(), fsync_fname(), fsync_parent_path(), and pg_file_sync().

{
    int         fd;
    int         flags;
    int         returncode;

    /*
     * Some OSs require directories to be opened read-only whereas other
     * systems don't allow us to fsync files opened read-only; so we need both
     * cases here.  Using O_RDWR will cause us to fail to fsync files that are
     * not writable by our userid, but we assume that's OK.
     */
    flags = PG_BINARY;
    if (!isdir)
        flags |= O_RDWR;
    else
        flags |= O_RDONLY;

    fd = OpenTransientFile(fname, flags);

    /*
     * Some OSs don't allow us to open directories at all (Windows returns
     * EACCES), just ignore the error in that case.  If desired also silently
     * ignoring errors about unreadable files. Log others.
     */
    if (fd < 0 && isdir && (errno == EISDIR || errno == EACCES))
        return 0;
    else if (fd < 0 && ignore_perm && errno == EACCES)
        return 0;
    else if (fd < 0)
    {
        ereport(elevel,
                (errcode_for_file_access(),
                 errmsg("could not open file \"%s\": %m", fname)));
        return -1;
    }

    returncode = pg_fsync(fd);

    /*
     * Some OSes don't allow us to fsync directories at all, so we can ignore
     * those errors. Anything else needs to be logged.
     */
    if (returncode != 0 && !(isdir && (errno == EBADF || errno == EINVAL)))
    {
        int         save_errno;

        /* close file upon error, might not be in transaction context */
        save_errno = errno;
        (void) CloseTransientFile(fd);
        errno = save_errno;

        ereport(elevel,
                (errcode_for_file_access(),
                 errmsg("could not fsync file \"%s\": %m", fname)));
        return -1;
    }

    if (CloseTransientFile(fd) != 0)
    {
        ereport(elevel,
                (errcode_for_file_access(),
                 errmsg("could not close file \"%s\": %m", fname)));
        return -1;
    }

    return 0;
}

GetNextTempTableSpace()

Oid GetNextTempTableSpace

(

void

)

Definition at line 2945 of file fd.c.

References InvalidOid, nextTempTableSpace, numTempTableSpaces, and tempTableSpaces.

Referenced by GetDefaultTablespace(), and OpenTemporaryFile().

{
    if (numTempTableSpaces > 0)
    {
        /* Advance nextTempTableSpace counter with wraparound */
        if (++nextTempTableSpace >= numTempTableSpaces)
            nextTempTableSpace = 0;
        return tempTableSpaces[nextTempTableSpace];
    }
    return InvalidOid;
}

GetTempTablespaces()

int GetTempTablespaces	(	Oid *	tableSpaces,
		int	numSpaces
	)

Definition at line 2927 of file fd.c.

References Assert, i, numTempTableSpaces, tempTableSpaces, and TempTablespacesAreSet().

Referenced by SharedFileSetInit().

{
    int         i;

    Assert(TempTablespacesAreSet());
    for (i = 0; i < numTempTableSpaces && i < numSpaces; ++i)
        tableSpaces[i] = tempTableSpaces[i];

    return i;
}

InitFileAccess()

void InitFileAccess

(

void

)

Definition at line 873 of file fd.c.

References Assert, AtProcExit_Files(), ereport, errcode(), errmsg(), FATAL, vfd::fd, malloc, MemSet, on_proc_exit(), SizeVfdCache, and VFD_CLOSED.

Referenced by BaseInit().

{
    Assert(SizeVfdCache == 0);  /* call me only once */

    /* initialize cache header entry */
    VfdCache = (Vfd *) malloc(sizeof(Vfd));
    if (VfdCache == NULL)
        ereport(FATAL,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory")));

    MemSet((char *) &(VfdCache[0]), 0, sizeof(Vfd));
    VfdCache->fd = VFD_CLOSED;

    SizeVfdCache = 1;

    /* register proc-exit hook to ensure temp files are dropped at exit */
    on_proc_exit(AtProcExit_Files, 0);
}

looks_like_temp_rel_name()

bool looks_like_temp_rel_name

(

const char *

name

)

Definition at line 3284 of file fd.c.

References CloseTransientFile(), ereport, errcode_for_file_access(), errmsg(), vfd::fd, forkname_chars(), LOG, and OpenTransientFile().

Referenced by RemovePgTempRelationFilesInDbspace(), and sendDir().

{
    int         pos;
    int         savepos;

    /* Must start with "t". */
    if (name[0] != 't')
        return false;

    /* Followed by a non-empty string of digits and then an underscore. */
    for (pos = 1; isdigit((unsigned char) name[pos]); ++pos)
        ;
    if (pos == 1 || name[pos] != '_')
        return false;

    /* Followed by another nonempty string of digits. */
    for (savepos = ++pos; isdigit((unsigned char) name[pos]); ++pos)
        ;
    if (savepos == pos)
        return false;

    /* We might have _forkname or .segment or both. */
    if (name[pos] == '_')
    {
        int         forkchar = forkname_chars(&name[pos + 1], NULL);

        if (forkchar <= 0)
            return false;
        pos += forkchar + 1;
    }
    if (name[pos] == '.')
    {
        int         segchar;

        for (segchar = 1; isdigit((unsigned char) name[pos + segchar]); ++segchar)
            ;
        if (segchar <= 1)
            return false;
        pos += segchar;
    }

    /* Now we should be at the end. */
    if (name[pos] != '\0')
        return false;
    return true;
}

MakePGDirectory()

int MakePGDirectory

(

const char *

directoryName

)

Definition at line 3735 of file fd.c.

References mkdir, and pg_dir_create_mode.

Referenced by BackendRun(), copydir(), create_tablespace_directories(), CreateSlotOnDisk(), OpenTemporaryFileInTablespace(), PathNameCreateTemporaryDir(), SysLogger_Start(), SysLoggerMain(), TablespaceCreateDbspace(), and ValidateXLOGDirectoryStructure().

{
    return mkdir(directoryName, pg_dir_create_mode);
}

OpenPipeStream()

FILE* OpenPipeStream	(	const char *	command,
		const char *	mode
	)

Definition at line 2520 of file fd.c.

References AllocateDescPipe, AllocateDesc::create_subid, AllocateDesc::desc, DO_DB, elog, ereport, errcode(), errmsg(), ERROR, AllocateDesc::file, GetCurrentSubTransactionId(), AllocateDesc::kind, LOG, maxAllocatedDescs, numAllocatedDescs, pqsignal(), ReleaseLruFile(), ReleaseLruFiles(), reserveAllocatedDesc(), SIG_DFL, SIG_IGN, SIGPIPE, and generate_unaccent_rules::stdout.

Referenced by BeginCopyFrom(), BeginCopyTo(), pg_import_system_collations(), and run_ssl_passphrase_command().

{
    FILE       *file;
    int         save_errno;

    DO_DB(elog(LOG, "OpenPipeStream: Allocated %d (%s)",
               numAllocatedDescs, command));

    /* Can we allocate another non-virtual FD? */
    if (!reserveAllocatedDesc())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_RESOURCES),
                 errmsg("exceeded maxAllocatedDescs (%d) while trying to execute command \"%s\"",
                        maxAllocatedDescs, command)));

    /* Close excess kernel FDs. */
    ReleaseLruFiles();

TryAgain:
    fflush(stdout);
    fflush(stderr);
    pqsignal(SIGPIPE, SIG_DFL);
    errno = 0;
    file = popen(command, mode);
    save_errno = errno;
    pqsignal(SIGPIPE, SIG_IGN);
    errno = save_errno;
    if (file != NULL)
    {
        AllocateDesc *desc = &allocatedDescs[numAllocatedDescs];

        desc->kind = AllocateDescPipe;
        desc->desc.file = file;
        desc->create_subid = GetCurrentSubTransactionId();
        numAllocatedDescs++;
        return desc->desc.file;
    }

    if (errno == EMFILE || errno == ENFILE)
    {
        ereport(LOG,
                (errcode(ERRCODE_INSUFFICIENT_RESOURCES),
                 errmsg("out of file descriptors: %m; release and retry")));
        if (ReleaseLruFile())
            goto TryAgain;
        errno = save_errno;
    }

    return NULL;
}

OpenTemporaryFile()

File OpenTemporaryFile

(

bool

interXact

)

Definition at line 1669 of file fd.c.

References CurrentResourceOwner, FD_DELETE_AT_CLOSE, FD_TEMP_FILE_LIMIT, vfd::fdstate, GetNextTempTableSpace(), MyDatabaseTableSpace, numTempTableSpaces, OidIsValid, OpenTemporaryFileInTablespace(), RegisterTemporaryFile(), and ResourceOwnerEnlargeFiles().

Referenced by BufFileCreateTemp(), and extendBufFile().

{
    File        file = 0;

    /*
     * Make sure the current resource owner has space for this File before we
     * open it, if we'll be registering it below.
     */
    if (!interXact)
        ResourceOwnerEnlargeFiles(CurrentResourceOwner);

    /*
     * If some temp tablespace(s) have been given to us, try to use the next
     * one.  If a given tablespace can't be found, we silently fall back to
     * the database's default tablespace.
     *
     * BUT: if the temp file is slated to outlive the current transaction,
     * force it into the database's default tablespace, so that it will not
     * pose a threat to possible tablespace drop attempts.
     */
    if (numTempTableSpaces > 0 && !interXact)
    {
        Oid         tblspcOid = GetNextTempTableSpace();

        if (OidIsValid(tblspcOid))
            file = OpenTemporaryFileInTablespace(tblspcOid, false);
    }

    /*
     * If not, or if tablespace is bad, create in database's default
     * tablespace.  MyDatabaseTableSpace should normally be set before we get
     * here, but just in case it isn't, fall back to pg_default tablespace.
     */
    if (file <= 0)
        file = OpenTemporaryFileInTablespace(MyDatabaseTableSpace ?
                                             MyDatabaseTableSpace :
                                             DEFAULTTABLESPACE_OID,
                                             true);

    /* Mark it for deletion at close and temporary file size limit */
    VfdCache[file].fdstate |= FD_DELETE_AT_CLOSE | FD_TEMP_FILE_LIMIT;

    /* Register it with the current resource owner */
    if (!interXact)
        RegisterTemporaryFile(file);

    return file;
}

OpenTransientFile()

int OpenTransientFile	(	const char *	fileName,
		int	fileFlags
	)

Definition at line 2467 of file fd.c.

References OpenTransientFilePerm(), and pg_file_create_mode.

Referenced by ApplyLogicalMappingFile(), CheckPointLogicalRewriteHeap(), CheckPointReplicationOrigin(), copy_file(), dsm_impl_mmap(), durable_rename(), fsync_fname_ext(), get_controlfile(), heap_xlog_logical_rewrite(), lo_import_internal(), load_relmap_file(), looks_like_temp_rel_name(), perform_base_backup(), pg_truncate(), qtext_load_file(), qtext_store(), ReadTwoPhaseFile(), RecreateTwoPhaseFile(), ReorderBufferSerializeTXN(), RestoreSlotFromDisk(), SaveSlotToPath(), sendFile(), SendTimeLineHistory(), SimpleLruDoesPhysicalPageExist(), SlruPhysicalReadPage(), SlruPhysicalWritePage(), SlruSyncFileTag(), SnapBuildRestore(), SnapBuildSerialize(), StartupReplicationOrigin(), walkdir(), write_relmap_file(), writeTimeLineHistory(), writeTimeLineHistoryFile(), and XLogFileCopy().

{
    return OpenTransientFilePerm(fileName, fileFlags, pg_file_create_mode);
}

OpenTransientFilePerm()

int OpenTransientFilePerm	(	const char *	fileName,
		int	fileFlags,
		mode_t	fileMode
	)

Definition at line 2476 of file fd.c.

References AllocateDescRawFD, BasicOpenFilePerm(), AllocateDesc::create_subid, AllocateDesc::desc, DO_DB, elog, ereport, errcode(), errmsg(), ERROR, vfd::fd, AllocateDesc::fd, GetCurrentSubTransactionId(), AllocateDesc::kind, LOG, maxAllocatedDescs, numAllocatedDescs, ReleaseLruFiles(), and reserveAllocatedDesc().

Referenced by be_lo_export(), and OpenTransientFile().

{
    int         fd;

    DO_DB(elog(LOG, "OpenTransientFile: Allocated %d (%s)",
               numAllocatedDescs, fileName));

    /* Can we allocate another non-virtual FD? */
    if (!reserveAllocatedDesc())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_RESOURCES),
                 errmsg("exceeded maxAllocatedDescs (%d) while trying to open file \"%s\"",
                        maxAllocatedDescs, fileName)));

    /* Close excess kernel FDs. */
    ReleaseLruFiles();

    fd = BasicOpenFilePerm(fileName, fileFlags, fileMode);

    if (fd >= 0)
    {
        AllocateDesc *desc = &allocatedDescs[numAllocatedDescs];

        desc->kind = AllocateDescRawFD;
        desc->desc.fd = fd;
        desc->create_subid = GetCurrentSubTransactionId();
        numAllocatedDescs++;

        return fd;
    }

    return -1;                  /* failure */
}

PathNameCreateTemporaryDir()

void PathNameCreateTemporaryDir	(	const char *	base,
		const char *	name
	)

Definition at line 1605 of file fd.c.

References ereport, errcode_for_file_access(), errmsg(), ERROR, and MakePGDirectory().

Referenced by SharedFileSetCreate().

{
    if (MakePGDirectory(directory) < 0)
    {
        if (errno == EEXIST)
            return;

        /*
         * Failed.  Try to create basedir first in case it's missing. Tolerate
         * EEXIST to close a race against another process following the same
         * algorithm.
         */
        if (MakePGDirectory(basedir) < 0 && errno != EEXIST)
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("cannot create temporary directory \"%s\": %m",
                            basedir)));

        /* Try again. */
        if (MakePGDirectory(directory) < 0 && errno != EEXIST)
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("cannot create temporary subdirectory \"%s\": %m",
                            directory)));
    }
}

PathNameCreateTemporaryFile()

File PathNameCreateTemporaryFile	(	const char *	name,
		bool	error_on_failure
	)

Definition at line 1804 of file fd.c.

References CurrentResourceOwner, ereport, errcode_for_file_access(), errmsg(), ERROR, FD_TEMP_FILE_LIMIT, vfd::fdstate, PathNameOpenFile(), PG_BINARY, RegisterTemporaryFile(), and ResourceOwnerEnlargeFiles().

Referenced by SharedFileSetCreate().

{
    File        file;

    ResourceOwnerEnlargeFiles(CurrentResourceOwner);

    /*
     * Open the file.  Note: we don't use O_EXCL, in case there is an orphaned
     * temp file that can be reused.
     */
    file = PathNameOpenFile(path, O_RDWR | O_CREAT | O_TRUNC | PG_BINARY);
    if (file <= 0)
    {
        if (error_on_failure)
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not create temporary file \"%s\": %m",
                            path)));
        else
            return file;
    }

    /* Mark it for temp_file_limit accounting. */
    VfdCache[file].fdstate |= FD_TEMP_FILE_LIMIT;

    /* Register it for automatic close. */
    RegisterTemporaryFile(file);

    return file;
}

PathNameDeleteTemporaryDir()

void PathNameDeleteTemporaryDir

(

const char *

name

)

Definition at line 1636 of file fd.c.

References LOG, stat, unlink_if_exists_fname(), and walkdir().

Referenced by SharedFileSetDeleteAll().

{
    struct stat statbuf;

    /* Silently ignore missing directory. */
    if (stat(dirname, &statbuf) != 0 && errno == ENOENT)
        return;

    /*
     * Currently, walkdir doesn't offer a way for our passed in function to
     * maintain state.  Perhaps it should, so that we could tell the caller
     * whether this operation succeeded or failed.  Since this operation is
     * used in a cleanup path, we wouldn't actually behave differently: we'll
     * just log failures.
     */
    walkdir(dirname, unlink_if_exists_fname, false, LOG);
}

PathNameDeleteTemporaryFile()

bool PathNameDeleteTemporaryFile	(	const char *	name,
		bool	error_on_failure
	)

Definition at line 1871 of file fd.c.

References ereport, errcode_for_file_access(), errmsg(), ERROR, LOG, ReportTemporaryFileUsage(), stat::st_size, and stat.

Referenced by SharedFileSetDelete(), and unlink_if_exists_fname().

{
    struct stat filestats;
    int         stat_errno;

    /* Get the final size for pgstat reporting. */
    if (stat(path, &filestats) != 0)
        stat_errno = errno;
    else
        stat_errno = 0;

    /*
     * Unlike FileClose's automatic file deletion code, we tolerate
     * non-existence to support BufFileDeleteShared which doesn't know how
     * many segments it has to delete until it runs out.
     */
    if (stat_errno == ENOENT)
        return false;

    if (unlink(path) < 0)
    {
        if (errno != ENOENT)
            ereport(error_on_failure ? ERROR : LOG,
                    (errcode_for_file_access(),
                     errmsg("could not unlink temporary file \"%s\": %m",
                            path)));
        return false;
    }

    if (stat_errno == 0)
        ReportTemporaryFileUsage(path, filestats.st_size);
    else
    {
        errno = stat_errno;
        ereport(LOG,
                (errcode_for_file_access(),
                 errmsg("could not stat file \"%s\": %m", path)));
    }

    return true;
}

PathNameOpenFile()

File PathNameOpenFile	(	const char *	fileName,
		int	fileFlags
	)

Definition at line 1528 of file fd.c.

References PathNameOpenFilePerm(), and pg_file_create_mode.

Referenced by _mdfd_openseg(), logical_rewrite_log_mapping(), mdcreate(), mdopenfork(), mdsyncfiletag(), OpenTemporaryFileInTablespace(), PathNameCreateTemporaryFile(), PathNameOpenTemporaryFile(), and ReorderBufferRestoreChanges().

{
    return PathNameOpenFilePerm(fileName, fileFlags, pg_file_create_mode);
}

PathNameOpenFilePerm()

File PathNameOpenFilePerm	(	const char *	fileName,
		int	fileFlags,
		mode_t	fileMode
	)

Definition at line 1541 of file fd.c.

References AllocateVfd(), BasicOpenFilePerm(), DO_DB, elog, ereport, errcode(), errmsg(), ERROR, vfd::fd, vfd::fdstate, vfd::fileFlags, vfd::fileMode, vfd::fileName, vfd::fileSize, free, FreeVfd(), Insert(), LOG, nfile, ReleaseLruFiles(), and vfd::resowner.

Referenced by PathNameOpenFile().

{
    char       *fnamecopy;
    File        file;
    Vfd        *vfdP;

    DO_DB(elog(LOG, "PathNameOpenFilePerm: %s %x %o",
               fileName, fileFlags, fileMode));

    /*
     * We need a malloc'd copy of the file name; fail cleanly if no room.
     */
    fnamecopy = strdup(fileName);
    if (fnamecopy == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory")));

    file = AllocateVfd();
    vfdP = &VfdCache[file];

    /* Close excess kernel FDs. */
    ReleaseLruFiles();

    vfdP->fd = BasicOpenFilePerm(fileName, fileFlags, fileMode);

    if (vfdP->fd < 0)
    {
        int         save_errno = errno;

        FreeVfd(file);
        free(fnamecopy);
        errno = save_errno;
        return -1;
    }
    ++nfile;
    DO_DB(elog(LOG, "PathNameOpenFile: success %d",
               vfdP->fd));

    vfdP->fileName = fnamecopy;
    /* Saved flags are adjusted to be OK for re-opening file */
    vfdP->fileFlags = fileFlags & ~(O_CREAT | O_TRUNC | O_EXCL);
    vfdP->fileMode = fileMode;
    vfdP->fileSize = 0;
    vfdP->fdstate = 0x0;
    vfdP->resowner = NULL;

    Insert(file);

    return file;
}

PathNameOpenTemporaryFile()

File PathNameOpenTemporaryFile	(	const char *	path,
		int	mode
	)

Definition at line 1842 of file fd.c.

References CurrentResourceOwner, ereport, errcode_for_file_access(), errmsg(), ERROR, PathNameOpenFile(), PG_BINARY, RegisterTemporaryFile(), and ResourceOwnerEnlargeFiles().

Referenced by SharedFileSetOpen().

{
    File        file;

    ResourceOwnerEnlargeFiles(CurrentResourceOwner);

    file = PathNameOpenFile(path, mode | PG_BINARY);

    /* If no such file, then we don't raise an error. */
    if (file <= 0 && errno != ENOENT)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not open temporary file \"%s\": %m",
                        path)));

    if (file > 0)
    {
        /* Register it for automatic close. */
        RegisterTemporaryFile(file);
    }

    return file;
}

pg_fdatasync()

int pg_fdatasync

(

int

fd

)

Definition at line 442 of file fd.c.

References enableFsync, and fsync.

Referenced by issue_xlog_fsync().

{
    if (enableFsync)
    {
#ifdef HAVE_FDATASYNC
        return fdatasync(fd);
#else
        return fsync(fd);
#endif
    }
    else
        return 0;
}

pg_flush_data()

void pg_flush_data	(	int	fd,
		off_t	offset,
		off_t	amount
	)

Definition at line 462 of file fd.c.

References data_sync_elevel(), elevel, enableFsync, ereport, errcode_for_file_access(), errmsg(), FATAL, MAP_FAILED, and WARNING.

Referenced by copy_file(), FileWriteback(), and walkdir().

{
    /*
     * Right now file flushing is primarily used to avoid making later
     * fsync()/fdatasync() calls have less impact. Thus don't trigger flushes
     * if fsyncs are disabled - that's a decision we might want to make
     * configurable at some point.
     */
    if (!enableFsync)
        return;

    /*
     * We compile all alternatives that are supported on the current platform,
     * to find portability problems more easily.
     */
#if defined(HAVE_SYNC_FILE_RANGE)
    {
        int         rc;
        static bool not_implemented_by_kernel = false;

        if (not_implemented_by_kernel)
            return;

        /*
         * sync_file_range(SYNC_FILE_RANGE_WRITE), currently linux specific,
         * tells the OS that writeback for the specified blocks should be
         * started, but that we don't want to wait for completion.  Note that
         * this call might block if too much dirty data exists in the range.
         * This is the preferable method on OSs supporting it, as it works
         * reliably when available (contrast to msync()) and doesn't flush out
         * clean data (like FADV_DONTNEED).
         */
        rc = sync_file_range(fd, offset, nbytes,
                             SYNC_FILE_RANGE_WRITE);
        if (rc != 0)
        {
            int         elevel;

            /*
             * For systems that don't have an implementation of
             * sync_file_range() such as Windows WSL, generate only one
             * warning and then suppress all further attempts by this process.
             */
            if (errno == ENOSYS)
            {
                elevel = WARNING;
                not_implemented_by_kernel = true;
            }
            else
                elevel = data_sync_elevel(WARNING);

            ereport(elevel,
                    (errcode_for_file_access(),
                     errmsg("could not flush dirty data: %m")));
        }

        return;
    }
#endif
#if !defined(WIN32) && defined(MS_ASYNC)
    {
        void       *p;
        static int  pagesize = 0;

        /*
         * On several OSs msync(MS_ASYNC) on a mmap'ed file triggers
         * writeback. On linux it only does so if MS_SYNC is specified, but
         * then it does the writeback synchronously. Luckily all common linux
         * systems have sync_file_range().  This is preferable over
         * FADV_DONTNEED because it doesn't flush out clean data.
         *
         * We map the file (mmap()), tell the kernel to sync back the contents
         * (msync()), and then remove the mapping again (munmap()).
         */

        /* mmap() needs actual length if we want to map whole file */
        if (offset == 0 && nbytes == 0)
        {
            nbytes = lseek(fd, 0, SEEK_END);
            if (nbytes < 0)
            {
                ereport(WARNING,
                        (errcode_for_file_access(),
                         errmsg("could not determine dirty data size: %m")));
                return;
            }
        }

        /*
         * Some platforms reject partial-page mmap() attempts.  To deal with
         * that, just truncate the request to a page boundary.  If any extra
         * bytes don't get flushed, well, it's only a hint anyway.
         */

        /* fetch pagesize only once */
        if (pagesize == 0)
            pagesize = sysconf(_SC_PAGESIZE);

        /* align length to pagesize, dropping any fractional page */
        if (pagesize > 0)
            nbytes = (nbytes / pagesize) * pagesize;

        /* fractional-page request is a no-op */
        if (nbytes <= 0)
            return;

        /*
         * mmap could well fail, particularly on 32-bit platforms where there
         * may simply not be enough address space.  If so, silently fall
         * through to the next implementation.
         */
        if (nbytes <= (off_t) SSIZE_MAX)
            p = mmap(NULL, nbytes, PROT_READ, MAP_SHARED, fd, offset);
        else
            p = MAP_FAILED;

        if (p != MAP_FAILED)
        {
            int         rc;

            rc = msync(p, (size_t) nbytes, MS_ASYNC);
            if (rc != 0)
            {
                ereport(data_sync_elevel(WARNING),
                        (errcode_for_file_access(),
                         errmsg("could not flush dirty data: %m")));
                /* NB: need to fall through to munmap()! */
            }

            rc = munmap(p, (size_t) nbytes);
            if (rc != 0)
            {
                /* FATAL error because mapping would remain */
                ereport(FATAL,
                        (errcode_for_file_access(),
                         errmsg("could not munmap() while flushing data: %m")));
            }

            return;
        }
    }
#endif
#if defined(USE_POSIX_FADVISE) && defined(POSIX_FADV_DONTNEED)
    {
        int         rc;

        /*
         * Signal the kernel that the passed in range should not be cached
         * anymore. This has the, desired, side effect of writing out dirty
         * data, and the, undesired, side effect of likely discarding useful
         * clean cached blocks.  For the latter reason this is the least
         * preferable method.
         */

        rc = posix_fadvise(fd, offset, nbytes, POSIX_FADV_DONTNEED);

        if (rc != 0)
        {
            /* don't error out, this is just a performance optimization */
            ereport(WARNING,
                    (errcode_for_file_access(),
                     errmsg("could not flush dirty data: %m")));
        }

        return;
    }
#endif
}

pg_fsync()

int pg_fsync

(

int

fd

)

Definition at line 352 of file fd.c.

References Assert, fstat, pg_fsync_no_writethrough(), pg_fsync_writethrough(), S_ISDIR, stat::st_mode, sync_method, and SYNC_METHOD_FSYNC_WRITETHROUGH.

Referenced by AddToDataDirLockFile(), assign_xlog_sync_method(), BootStrapXLOG(), CheckPointLogicalRewriteHeap(), CreateLockFile(), do_pg_start_backup(), durable_rename(), FileSync(), fsync_fname_ext(), heap_xlog_logical_rewrite(), readRecoverySignalFile(), RecreateTwoPhaseFile(), RestoreSlotFromDisk(), SaveSlotToPath(), SlruPhysicalWritePage(), SlruSyncFileTag(), SnapBuildSerialize(), update_controlfile(), write_auto_conf_file(), write_relmap_file(), WriteControlFile(), writeTimeLineHistory(), writeTimeLineHistoryFile(), XLogFileCopy(), and XLogFileInitInternal().

{
#if !defined(WIN32) && defined(USE_ASSERT_CHECKING)
    struct stat st;

    /*
     * Some operating system implementations of fsync() have requirements
     * about the file access modes that were used when their file descriptor
     * argument was opened, and these requirements differ depending on whether
     * the file descriptor is for a directory.
     *
     * For any file descriptor that may eventually be handed to fsync(), we
     * should have opened it with access modes that are compatible with
     * fsync() on all supported systems, otherwise the code may not be
     * portable, even if it runs ok on the current system.
     *
     * We assert here that a descriptor for a file was opened with write
     * permissions (either O_RDWR or O_WRONLY) and for a directory without
     * write permissions (O_RDONLY).
     *
     * Ignore any fstat errors and let the follow-up fsync() do its work.
     * Doing this sanity check here counts for the case where fsync() is
     * disabled.
     */
    if (fstat(fd, &st) == 0)
    {
        int         desc_flags = fcntl(fd, F_GETFL);

        /*
         * O_RDONLY is historically 0, so just make sure that for directories
         * no write flags are used.
         */
        if (S_ISDIR(st.st_mode))
            Assert((desc_flags & (O_RDWR | O_WRONLY)) == 0);
        else
            Assert((desc_flags & (O_RDWR | O_WRONLY)) != 0);
    }
    errno = 0;
#endif

    /* #if is to skip the sync_method test if there's no need for it */
#if defined(HAVE_FSYNC_WRITETHROUGH) && !defined(FSYNC_WRITETHROUGH_IS_FSYNC)
    if (sync_method == SYNC_METHOD_FSYNC_WRITETHROUGH)
        return pg_fsync_writethrough(fd);
    else
#endif
        return pg_fsync_no_writethrough(fd);
}

pg_fsync_no_writethrough()

int pg_fsync_no_writethrough

(

int

fd

)

Definition at line 407 of file fd.c.

References enableFsync, and fsync.

Referenced by issue_xlog_fsync(), and pg_fsync().

{
    if (enableFsync)
        return fsync(fd);
    else
        return 0;
}

pg_fsync_writethrough()

int pg_fsync_writethrough

(

int

fd

)

Definition at line 419 of file fd.c.

References enableFsync.

Referenced by issue_xlog_fsync(), pg_fsync(), signal_cleanup(), and test_sync().

{
    if (enableFsync)
    {
#ifdef WIN32
        return _commit(fd);
#elif defined(F_FULLFSYNC)
        return (fcntl(fd, F_FULLFSYNC, 0) == -1) ? -1 : 0;
#else
        errno = ENOSYS;
        return -1;
#endif
    }
    else
        return 0;
}

pg_pwritev_with_retry()

ssize_t pg_pwritev_with_retry	(	int	fd,
		const struct iovec *	iov,
		int	iovcnt,
		off_t	offset
	)

Definition at line 3768 of file fd.c.

References Assert, iovec::iov_base, iovec::iov_len, Min, and pg_pwritev().

Referenced by XLogFileInitInternal().

{
    struct iovec iov_copy[PG_IOV_MAX];
    ssize_t     sum = 0;
    ssize_t     part;

    /* We'd better have space to make a copy, in case we need to retry. */
    if (iovcnt > PG_IOV_MAX)
    {
        errno = EINVAL;
        return -1;
    }

    for (;;)
    {
        /* Write as much as we can. */
        part = pg_pwritev(fd, iov, iovcnt, offset);
        if (part < 0)
            return -1;

#ifdef SIMULATE_SHORT_WRITE
        part = Min(part, 4096);
#endif

        /* Count our progress. */
        sum += part;
        offset += part;

        /* Step over iovecs that are done. */
        while (iovcnt > 0 && iov->iov_len <= part)
        {
            part -= iov->iov_len;
            ++iov;
            --iovcnt;
        }

        /* Are they all done? */
        if (iovcnt == 0)
        {
            /* We don't expect the kernel to write more than requested. */
            Assert(part == 0);
            break;
        }

        /*
         * Move whatever's left to the front of our mutable copy and adjust
         * the leading iovec.
         */
        Assert(iovcnt > 0);
        memmove(iov_copy, iov, sizeof(*iov) * iovcnt);
        Assert(iov->iov_len > part);
        iov_copy[0].iov_base = (char *) iov_copy[0].iov_base + part;
        iov_copy[0].iov_len -= part;
        iov = iov_copy;
    }

    return sum;
}

pg_truncate()

int pg_truncate	(	const char *	path,
		off_t	length
	)

Definition at line 635 of file fd.c.

References CloseTransientFile(), vfd::fd, ftruncate, OpenTransientFile(), and PG_BINARY.

Referenced by do_truncate().

{
#ifdef WIN32
    int         save_errno;
    int         ret;
    int         fd;

    fd = OpenTransientFile(path, O_RDWR | PG_BINARY);
    if (fd >= 0)
    {
        ret = ftruncate(fd, 0);
        save_errno = errno;
        CloseTransientFile(fd);
        errno = save_errno;
    }
    else
        ret = -1;

    return ret;
#else
    return truncate(path, length);
#endif
}

ReadDir()

struct dirent* ReadDir	(	DIR *	dir,
		const char *	dirname
	)

Definition at line 2744 of file fd.c.

References ERROR, and ReadDirExtended().

Referenced by calculate_database_size(), calculate_tablespace_size(), CheckPointLogicalRewriteHeap(), CheckPointSnapBuild(), CleanupBackupHistory(), copydir(), db_dir_size(), destroy_tablespace_directories(), directory_is_empty(), do_pg_start_backup(), dsm_cleanup_for_mmap(), extension_file_exists(), get_ext_ver_list(), movedb(), perform_base_backup(), pg_available_extension_versions(), pg_available_extensions(), pg_logdir_ls_internal(), pg_ls_dir(), pg_ls_dir_files(), pg_tablespace_databases(), pg_tzenumerate_next(), pgarch_readyXlog(), pgstat_reset_remove_files(), RemoveNonParentXlogFiles(), RemoveOldXlogFiles(), RemoveTempXlogFiles(), ResetUnloggedRelations(), ResetUnloggedRelationsInDbspaceDir(), ResetUnloggedRelationsInTablespaceDir(), restoreTwoPhaseData(), sendDir(), SlruScanDirectory(), StartupReorderBuffer(), StartupReplicationSlots(), and UpdateLogicalMappings().

{
    return ReadDirExtended(dir, dirname, ERROR);
}

ReadDirExtended()

struct dirent* ReadDirExtended	(	DIR *	dir,
		const char *	dirname,
		int	elevel
	)

Definition at line 2759 of file fd.c.

References ereport, errcode_for_file_access(), errmsg(), and readdir().

Referenced by DeleteAllExportedSnapshotFiles(), ReadDir(), RelationCacheInitFileRemove(), RelationCacheInitFileRemoveInDir(), RemovePgTempFiles(), RemovePgTempFilesInDir(), RemovePgTempRelationFiles(), RemovePgTempRelationFilesInDbspace(), ReorderBufferCleanupSerializedTXNs(), scan_directory_ci(), SyncDataDirectory(), and walkdir().

{
    struct dirent *dent;

    /* Give a generic message for AllocateDir failure, if caller didn't */
    if (dir == NULL)
    {
        ereport(elevel,
                (errcode_for_file_access(),
                 errmsg("could not open directory \"%s\": %m",
                        dirname)));
        return NULL;
    }

    errno = 0;
    if ((dent = readdir(dir)) != NULL)
        return dent;

    if (errno)
        ereport(elevel,
                (errcode_for_file_access(),
                 errmsg("could not read directory \"%s\": %m",
                        dirname)));
    return NULL;
}

ReleaseExternalFD()

void ReleaseExternalFD

(

void

)

Definition at line 1192 of file fd.c.

References Assert, buf, elog, LOG, vfd::lruLessRecently, numExternalFDs, and snprintf.

Referenced by ClosePostmasterPorts(), connect_pg_server(), createNewConnection(), CreateWaitEventSet(), dblink_connect(), dblink_disconnect(), dblink_exec(), dblink_get_conn(), dblink_record_internal(), dblink_security_check(), disconnect_pg_server(), dsm_impl_op(), FreeWaitEventSet(), InitializeLatchSupport(), and XLogFileClose().

{
    Assert(numExternalFDs > 0);
    numExternalFDs--;
}

RemovePgTempFiles()

void RemovePgTempFiles

(

void

)

Definition at line 3103 of file fd.c.

References AllocateDir(), dirent::d_name, FreeDir(), LOG, MAXPGPATH, PG_TEMP_FILES_DIR, ReadDirExtended(), RemovePgTempFilesInDir(), RemovePgTempRelationFiles(), snprintf, and TABLESPACE_VERSION_DIRECTORY.

Referenced by PostmasterMain(), and PostmasterStateMachine().

{
    char        temp_path[MAXPGPATH + 10 + sizeof(TABLESPACE_VERSION_DIRECTORY) + sizeof(PG_TEMP_FILES_DIR)];
    DIR        *spc_dir;
    struct dirent *spc_de;

    /*
     * First process temp files in pg_default ($PGDATA/base)
     */
    snprintf(temp_path, sizeof(temp_path), "base/%s", PG_TEMP_FILES_DIR);
    RemovePgTempFilesInDir(temp_path, true, false);
    RemovePgTempRelationFiles("base");

    /*
     * Cycle through temp directories for all non-default tablespaces.
     */
    spc_dir = AllocateDir("pg_tblspc");

    while ((spc_de = ReadDirExtended(spc_dir, "pg_tblspc", 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);
        RemovePgTempFilesInDir(temp_path, true, false);

        snprintf(temp_path, sizeof(temp_path), "pg_tblspc/%s/%s",
                 spc_de->d_name, TABLESPACE_VERSION_DIRECTORY);
        RemovePgTempRelationFiles(temp_path);
    }

    FreeDir(spc_dir);

    /*
     * In EXEC_BACKEND case there is a pgsql_tmp directory at the top level of
     * DataDir as well.  However, that is *not* cleaned here because doing so
     * would create a race condition.  It's done separately, earlier in
     * postmaster startup.
     */
}

RemovePgTempFilesInDir()

void RemovePgTempFilesInDir	(	const char *	tmpdirname,
		bool	missing_ok,
		bool	unlink_all
	)

Definition at line 3162 of file fd.c.

References AllocateDir(), dirent::d_name, ereport, errcode_for_file_access(), errmsg(), FreeDir(), LOG, lstat, MAXPGPATH, PG_TEMP_FILE_PREFIX, ReadDirExtended(), RemovePgTempFilesInDir(), S_ISDIR, snprintf, and stat::st_mode.

Referenced by PostmasterMain(), RemovePgTempFiles(), and RemovePgTempFilesInDir().

{
    DIR        *temp_dir;
    struct dirent *temp_de;
    char        rm_path[MAXPGPATH * 2];

    temp_dir = AllocateDir(tmpdirname);

    if (temp_dir == NULL && errno == ENOENT && missing_ok)
        return;

    while ((temp_de = ReadDirExtended(temp_dir, tmpdirname, LOG)) != NULL)
    {
        if (strcmp(temp_de->d_name, ".") == 0 ||
            strcmp(temp_de->d_name, "..") == 0)
            continue;

        snprintf(rm_path, sizeof(rm_path), "%s/%s",
                 tmpdirname, temp_de->d_name);

        if (unlink_all ||
            strncmp(temp_de->d_name,
                    PG_TEMP_FILE_PREFIX,
                    strlen(PG_TEMP_FILE_PREFIX)) == 0)
        {
            struct stat statbuf;

            if (lstat(rm_path, &statbuf) < 0)
            {
                ereport(LOG,
                        (errcode_for_file_access(),
                         errmsg("could not stat file \"%s\": %m", rm_path)));
                continue;
            }

            if (S_ISDIR(statbuf.st_mode))
            {
                /* recursively remove contents, then directory itself */
                RemovePgTempFilesInDir(rm_path, false, true);

                if (rmdir(rm_path) < 0)
                    ereport(LOG,
                            (errcode_for_file_access(),
                             errmsg("could not remove directory \"%s\": %m",
                                    rm_path)));
            }
            else
            {
                if (unlink(rm_path) < 0)
                    ereport(LOG,
                            (errcode_for_file_access(),
                             errmsg("could not remove file \"%s\": %m",
                                    rm_path)));
            }
        }
        else
            ereport(LOG,
                    (errmsg("unexpected file found in temporary-files directory: \"%s\"",
                            rm_path)));
    }

    FreeDir(temp_dir);
}

ReserveExternalFD()

void ReserveExternalFD

(

void

)

Definition at line 1174 of file fd.c.

References numExternalFDs, and ReleaseLruFiles().

Referenced by AcquireExternalFD(), BackendInitialize(), dsm_impl_op(), InitializeLatchSupport(), InitPostmasterDeathWatchHandle(), pgstat_init(), PostmasterMarkPIDForWorkerNotify(), and XLogWrite().

{
    /*
     * Release VFDs if needed to stay safe.  Because we do this before
     * incrementing numExternalFDs, the final state will be as desired, i.e.,
     * nfile + numAllocatedDescs + numExternalFDs <= max_safe_fds.
     */
    ReleaseLruFiles();

    numExternalFDs++;
}

set_max_safe_fds()

void set_max_safe_fds

(

void

)

Definition at line 990 of file fd.c.

References count_usable_fds(), DEBUG2, elog, ereport, errcode(), errdetail(), errmsg(), FATAL, FD_MINFREE, max_files_per_process, max_safe_fds, Min, and NUM_RESERVED_FDS.

Referenced by PostmasterMain().

{
    int         usable_fds;
    int         already_open;

    /*----------
     * We want to set max_safe_fds to
     *          MIN(usable_fds, max_files_per_process - already_open)
     * less the slop factor for files that are opened without consulting
     * fd.c.  This ensures that we won't exceed either max_files_per_process
     * or the experimentally-determined EMFILE limit.
     *----------
     */
    count_usable_fds(max_files_per_process,
                     &usable_fds, &already_open);

    max_safe_fds = Min(usable_fds, max_files_per_process - already_open);

    /*
     * Take off the FDs reserved for system() etc.
     */
    max_safe_fds -= NUM_RESERVED_FDS;

    /*
     * Make sure we still have enough to get by.
     */
    if (max_safe_fds < FD_MINFREE)
        ereport(FATAL,
                (errcode(ERRCODE_INSUFFICIENT_RESOURCES),
                 errmsg("insufficient file descriptors available to start server process"),
                 errdetail("System allows %d, we need at least %d.",
                           max_safe_fds + NUM_RESERVED_FDS,
                           FD_MINFREE + NUM_RESERVED_FDS)));

    elog(DEBUG2, "max_safe_fds = %d, usable_fds = %d, already_open = %d",
         max_safe_fds, usable_fds, already_open);
}

SetTempTablespaces()

void SetTempTablespaces	(	Oid *	tableSpaces,
		int	numSpaces
	)

Definition at line 2884 of file fd.c.

References Assert, nextTempTableSpace, numTempTableSpaces, random(), and tempTableSpaces.

Referenced by assign_temp_tablespaces(), and PrepareTempTablespaces().

{
    Assert(numSpaces >= 0);
    tempTableSpaces = tableSpaces;
    numTempTableSpaces = numSpaces;

    /*
     * Select a random starting point in the list.  This is to minimize
     * conflicts between backends that are most likely sharing the same list
     * of temp tablespaces.  Note that if we create multiple temp files in the
     * same transaction, we'll advance circularly through the list --- this
     * ensures that large temporary sort files are nicely spread across all
     * available tablespaces.
     */
    if (numSpaces > 1)
        nextTempTableSpace = random() % numSpaces;
    else
        nextTempTableSpace = 0;
}

SyncDataDirectory()

void SyncDataDirectory

(

void

)

Definition at line 3376 of file fd.c.

References AllocateDir(), dirent::d_name, datadir_fsync_fname(), DEBUG1, enableFsync, ereport, errcode_for_file_access(), errmsg(), FreeDir(), LOG, lstat, MAXPGPATH, pgwin32_is_junction(), ReadDirExtended(), recovery_init_sync_method, RECOVERY_INIT_SYNC_METHOD_SYNCFS, snprintf, stat::st_mode, and walkdir().

Referenced by StartupXLOG().

{
    bool        xlog_is_symlink;

    /* We can skip this whole thing if fsync is disabled. */
    if (!enableFsync)
        return;

    /*
     * If pg_wal is a symlink, we'll need to recurse into it separately,
     * because the first walkdir below will ignore it.
     */
    xlog_is_symlink = false;

#ifndef WIN32
    {
        struct stat st;

        if (lstat("pg_wal", &st) < 0)
            ereport(LOG,
                    (errcode_for_file_access(),
                     errmsg("could not stat file \"%s\": %m",
                            "pg_wal")));
        else if (S_ISLNK(st.st_mode))
            xlog_is_symlink = true;
    }
#else
    if (pgwin32_is_junction("pg_wal"))
        xlog_is_symlink = true;
#endif

#ifdef HAVE_SYNCFS
    if (recovery_init_sync_method == RECOVERY_INIT_SYNC_METHOD_SYNCFS)
    {
        DIR        *dir;
        struct dirent *de;

        /*
         * On Linux, we don't have to open every single file one by one.  We
         * can use syncfs() to sync whole filesystems.  We only expect
         * filesystem boundaries to exist where we tolerate symlinks, namely
         * pg_wal and the tablespaces, so we call syncfs() for each of those
         * directories.
         */

        /* 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)))
        {
            char        path[MAXPGPATH];

            if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0)
                continue;

            snprintf(path, MAXPGPATH, "pg_tblspc/%s", de->d_name);
            do_syncfs(path);
        }
        FreeDir(dir);
        /* If pg_wal is a symlink, process that too. */
        if (xlog_is_symlink)
            do_syncfs("pg_wal");
        return;
    }
#endif                          /* !HAVE_SYNCFS */

    /*
     * If possible, hint to the kernel that we're soon going to fsync the data
     * directory and its contents.  Errors in this step are even less
     * interesting than normal, so log them only at DEBUG1.
     */
#ifdef PG_FLUSH_DATA_WORKS
    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);
#endif

    /*
     * 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.
     */
    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);
}

TempTablespacePath()

void TempTablespacePath	(	char *	path,
		Oid	tablespace
	)

Definition at line 1722 of file fd.c.

References InvalidOid, MAXPGPATH, PG_TEMP_FILES_DIR, snprintf, and TABLESPACE_VERSION_DIRECTORY.

Referenced by OpenTemporaryFileInTablespace(), pg_ls_tmpdir(), SharedFileSetCreate(), and SharedFileSetPath().

{
    /*
     * Identify the tempfile directory for this tablespace.
     *
     * If someone tries to specify pg_global, use pg_default instead.
     */
    if (tablespace == InvalidOid ||
        tablespace == DEFAULTTABLESPACE_OID ||
        tablespace == GLOBALTABLESPACE_OID)
        snprintf(path, MAXPGPATH, "base/%s", PG_TEMP_FILES_DIR);
    else
    {
        /* All other tablespaces are accessed via symlinks */
        snprintf(path, MAXPGPATH, "pg_tblspc/%u/%s/%s",
                 tablespace, TABLESPACE_VERSION_DIRECTORY,
                 PG_TEMP_FILES_DIR);
    }
}

TempTablespacesAreSet()

bool TempTablespacesAreSet

(

void

)

Definition at line 2912 of file fd.c.

References numTempTableSpaces.

Referenced by GetTempTablespaces(), and PrepareTempTablespaces().

{
    return (numTempTableSpaces >= 0);
}

Variable Documentation

data_sync_retry

PGDLLIMPORT bool data_sync_retry

Definition at line 161 of file fd.c.

Referenced by data_sync_elevel().

max_files_per_process

PGDLLIMPORT int max_files_per_process

Definition at line 145 of file fd.c.

Referenced by set_max_safe_fds().

max_safe_fds

int max_safe_fds

Definition at line 158 of file fd.c.

Referenced by AcquireExternalFD(), PostmasterMarkPIDForWorkerNotify(), ReleaseLruFiles(), reserveAllocatedDesc(), and set_max_safe_fds().

recovery_init_sync_method

int recovery_init_sync_method

Definition at line 164 of file fd.c.

Referenced by SyncDataDirectory().