fd.c File Reference

#include "postgres.h"
#include <sys/file.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <limits.h>
#include <unistd.h>
#include <fcntl.h>
#include "miscadmin.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "catalog/catalog.h"
#include "catalog/pg_tablespace.h"
#include "pgstat.h"
#include "portability/mem.h"
#include "storage/fd.h"
#include "storage/ipc.h"
#include "utils/guc.h"
#include "utils/resowner_private.h"

Include dependency graph for fd.c:

Go to the source code of this file.

Data Structures
struct	vfd
struct	AllocateDesc

Macros
#define	NUM_RESERVED_FDS   10
#define	FD_MINFREE   10
#define	DO_DB(A)   ((void) 0)
#define	VFD_CLOSED   (-1)
#define	FileIsValid(file)   ((file) > 0 && (file) < (int) SizeVfdCache && VfdCache[file].fileName != NULL)
#define	FileIsNotOpen(file)   (VfdCache[file].fd == VFD_CLOSED)
#define	FileUnknownPos   ((off_t) -1)
#define	FilePosIsUnknown(pos)   ((pos) < 0)
#define	FD_TEMPORARY   (1 << 0) /* T = delete when closed */
#define	FD_XACT_TEMPORARY   (1 << 1) /* T = delete at eoXact */

Typedefs
typedef struct vfd	Vfd

Enumerations
enum	AllocateDescKind { AllocateDescFile, AllocateDescPipe, AllocateDescDir, AllocateDescRawFD }

Functions
static void	Delete (File file)
static void	LruDelete (File file)
static void	Insert (File file)
static int	LruInsert (File file)
static bool	ReleaseLruFile (void)
static void	ReleaseLruFiles (void)
static File	AllocateVfd (void)
static void	FreeVfd (File file)
static int	FileAccess (File file)
static File	OpenTemporaryFileInTablespace (Oid tblspcOid, bool rejectError)
static bool	reserveAllocatedDesc (void)
static int	FreeDesc (AllocateDesc *desc)
static struct dirent *	ReadDirExtended (DIR *dir, const char *dirname, int elevel)
static void	AtProcExit_Files (int code, Datum arg)
static void	CleanupTempFiles (bool isProcExit)
static void	RemovePgTempFilesInDir (const char *tmpdirname)
static void	RemovePgTempRelationFiles (const char *tsdirname)
static void	RemovePgTempRelationFilesInDbspace (const char *dbspacedirname)
static bool	looks_like_temp_rel_name (const char *name)
static void	walkdir (const char *path, void(*action)(const char *fname, bool isdir, int elevel), bool process_symlinks, int elevel)
static void	datadir_fsync_fname (const char *fname, bool isdir, int elevel)
static int	fsync_fname_ext (const char *fname, bool isdir, bool ignore_perm, int elevel)
static int	fsync_parent_path (const char *fname, int elevel)
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 nbytes)
void	fsync_fname (const char *fname, bool isdir)
int	durable_rename (const char *oldfile, const char *newfile, int elevel)
int	durable_unlink (const char *fname, int elevel)
int	durable_link_or_rename (const char *oldfile, const char *newfile, int elevel)
void	InitFileAccess (void)
static void	count_usable_fds (int max_to_probe, int *usable_fds, int *already_open)
void	set_max_safe_fds (void)
int	BasicOpenFile (FileName fileName, int fileFlags, int fileMode)
File	PathNameOpenFile (FileName fileName, int fileFlags, int fileMode)
File	OpenTemporaryFile (bool interXact)
void	FileClose (File file)
int	FilePrefetch (File file, off_t offset, int amount, uint32 wait_event_info)
void	FileWriteback (File file, off_t offset, off_t nbytes, uint32 wait_event_info)
int	FileRead (File file, char *buffer, int amount, uint32 wait_event_info)
int	FileWrite (File file, char *buffer, int amount, uint32 wait_event_info)
int	FileSync (File file, uint32 wait_event_info)
off_t	FileSeek (File file, off_t offset, int whence)
int	FileTruncate (File file, off_t offset, uint32 wait_event_info)
char *	FilePathName (File file)
int	FileGetRawDesc (File file)
int	FileGetRawFlags (File file)
int	FileGetRawMode (File file)
FILE *	AllocateFile (const char *name, const char *mode)
int	OpenTransientFile (FileName fileName, int fileFlags, int fileMode)
FILE *	OpenPipeStream (const char *command, const char *mode)
int	FreeFile (FILE *file)
int	CloseTransientFile (int fd)
DIR *	AllocateDir (const char *dirname)
struct dirent *	ReadDir (DIR *dir, const char *dirname)
int	FreeDir (DIR *dir)
int	ClosePipeStream (FILE *file)
void	closeAllVfds (void)
void	SetTempTablespaces (Oid *tableSpaces, int numSpaces)
bool	TempTablespacesAreSet (void)
Oid	GetNextTempTableSpace (void)
void	AtEOSubXact_Files (bool isCommit, SubTransactionId mySubid, SubTransactionId parentSubid)
void	AtEOXact_Files (void)
void	RemovePgTempFiles (void)
void	SyncDataDirectory (void)

Variables
int	max_files_per_process = 1000
int	max_safe_fds = 32
static Vfd *	VfdCache
static Size	SizeVfdCache = 0
static int	nfile = 0
static bool	have_xact_temporary_files = false
static uint64	temporary_files_size = 0
static int	numAllocatedDescs = 0
static int	maxAllocatedDescs = 0
static AllocateDesc *	allocatedDescs = NULL
static long	tempFileCounter = 0
static Oid *	tempTableSpaces = NULL
static int	numTempTableSpaces = -1
static int	nextTempTableSpace = 0

Macro Definition Documentation

#define DO_DB

(

A

)

((void) 0)

Definition at line 152 of file fd.c.

Referenced by AllocateDir(), AllocateFile(), AllocateVfd(), ClosePipeStream(), CloseTransientFile(), Delete(), FileAccess(), FileClose(), FilePrefetch(), FileRead(), FileSeek(), FileSync(), FileTruncate(), FileWrite(), FileWriteback(), FreeDir(), FreeFile(), FreeVfd(), Insert(), LruDelete(), LruInsert(), OpenPipeStream(), OpenTransientFile(), PathNameOpenFile(), and ReleaseLruFile().

#define FD_MINFREE   10

Definition at line 117 of file fd.c.

Referenced by reserveAllocatedDesc(), and set_max_safe_fds().

#define FD_TEMPORARY   (1 << 0) /* T = delete when closed */

Definition at line 173 of file fd.c.

Referenced by CleanupTempFiles(), FileClose(), FileTruncate(), FileWrite(), and OpenTemporaryFile().

#define FD_XACT_TEMPORARY   (1 << 1) /* T = delete at eoXact */

Definition at line 174 of file fd.c.

Referenced by CleanupTempFiles(), and OpenTemporaryFile().

#define FileIsNotOpen

(

file

)

(VfdCache[file].fd == VFD_CLOSED)

Definition at line 161 of file fd.c.

Referenced by CleanupTempFiles(), closeAllVfds(), FileAccess(), FileClose(), FileSeek(), and LruInsert().

#define FileIsValid

(

file

)

((file) > 0 && (file) < (int) SizeVfdCache && VfdCache[file].fileName != NULL)

Definition at line 158 of file fd.c.

Referenced by FileClose(), FileGetRawDesc(), FileGetRawFlags(), FileGetRawMode(), FilePathName(), FilePrefetch(), FileRead(), FileSeek(), FileSync(), FileTruncate(), FileWrite(), and FileWriteback().

#define FilePosIsUnknown

(

pos

)

((pos) < 0)

Definition at line 170 of file fd.c.

Referenced by FileRead(), FileSeek(), FileWrite(), and LruDelete().

#define FileUnknownPos   ((off_t) -1)

Definition at line 169 of file fd.c.

Referenced by FileRead(), and FileWrite().

#define NUM_RESERVED_FDS   10

Definition at line 111 of file fd.c.

Referenced by set_max_safe_fds().

#define VFD_CLOSED   (-1)

Definition at line 156 of file fd.c.

Referenced by AllocateVfd(), FileClose(), InitFileAccess(), LruDelete(), and LruInsert().

Typedef Documentation

typedef struct vfd Vfd

Enumeration Type Documentation

enum AllocateDescKind

Enumerator
AllocateDescFile
AllocateDescPipe
AllocateDescDir
AllocateDescRawFD

Definition at line 223 of file fd.c.

{
    AllocateDescFile,
    AllocateDescPipe,
    AllocateDescDir,
    AllocateDescRawFD
} AllocateDescKind;

Function Documentation

DIR* AllocateDir

(

const char *

dirname

)

Definition at line 2335 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, NULL, 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(), dsm_cleanup_for_mmap(), get_ext_ver_list(), getInstallationPaths(), movedb(), ParseTzFile(), perform_base_backup(), pg_available_extension_versions(), pg_available_extensions(), pg_logdir_ls(), pg_ls_dir(), pg_ls_dir_files(), pg_start_backup(), pg_tablespace_databases(), pg_tzenumerate_next(), pg_tzenumerate_start(), pgarch_readyXlog(), pgstat_reset_remove_files(), RelationCacheInitFileRemove(), RelationCacheInitFileRemoveInDir(), RemoveNonParentXlogFiles(), RemoveOldXlogFiles(), RemovePgTempFiles(), RemovePgTempFilesInDir(), RemovePgTempRelationFiles(), RemovePgTempRelationFilesInDbspace(), ResetUnloggedRelations(), ResetUnloggedRelationsInDbspaceDir(), ResetUnloggedRelationsInTablespaceDir(), restoreTwoPhaseData(), scan_directory_ci(), SendBaseBackup(), sendDir(), SlruScanDirectory(), StartupReorderBuffer(), StartupReplicationSlots(), 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;
}

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

Definition at line 2094 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, NULL, numAllocatedDescs, ReleaseLruFile(), ReleaseLruFiles(), and reserveAllocatedDesc().

Referenced by AlterSystemSetConfigFile(), BeginCopyFrom(), BeginCopyTo(), checkDataDir(), do_pg_start_backup(), do_pg_stop_backup(), entry_reset(), existsTimeLineHistory(), ExportSnapshot(), fill_hba_view(), gc_qtexts(), ImportSnapshot(), load_hba(), load_ident(), load_relcache_init_file(), parse_extension_control_file(), ParseTzFile(), perform_base_backup(), pg_backup_start_time(), pg_current_logfile(), pg_file_write(), 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(), read_backup_label(), read_binary_file(), read_tablespace_map(), read_whole_file(), readRecoveryCommandFile(), readTimeLineHistory(), sendFile(), 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;
}

static File AllocateVfd ( void  )

static

Definition at line 1172 of file fd.c.

References Assert, DO_DB, elog, ereport, errcode(), errmsg(), ERROR, vfd::fd, i, LOG, MemSet, vfd::nextFree, NULL, realloc, SizeVfdCache, and VFD_CLOSED.

Referenced by PathNameOpenFile().

{
    Index       i;
    File        file;

    DO_DB(elog(LOG, "AllocateVfd. Size %zu", SizeVfdCache));

    Assert(SizeVfdCache > 0);   /* InitFileAccess not called? */

    if (VfdCache[0].nextFree == 0)
    {
        /*
         * The free list is empty so it is time to increase the size of the
         * array.  We choose to double it each time this happens. However,
         * there's not much point in starting *real* small.
         */
        Size        newCacheSize = SizeVfdCache * 2;
        Vfd        *newVfdCache;

        if (newCacheSize < 32)
            newCacheSize = 32;

        /*
         * Be careful not to clobber VfdCache ptr if realloc fails.
         */
        newVfdCache = (Vfd *) realloc(VfdCache, sizeof(Vfd) * newCacheSize);
        if (newVfdCache == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_OUT_OF_MEMORY),
                     errmsg("out of memory")));
        VfdCache = newVfdCache;

        /*
         * Initialize the new entries and link them into the free list.
         */
        for (i = SizeVfdCache; i < newCacheSize; i++)
        {
            MemSet((char *) &(VfdCache[i]), 0, sizeof(Vfd));
            VfdCache[i].nextFree = i + 1;
            VfdCache[i].fd = VFD_CLOSED;
        }
        VfdCache[newCacheSize - 1].nextFree = 0;
        VfdCache[0].nextFree = SizeVfdCache;

        /*
         * Record the new size
         */
        SizeVfdCache = newCacheSize;
    }

    file = VfdCache[0].nextFree;

    VfdCache[0].nextFree = VfdCache[file].nextFree;

    return file;
}

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

Definition at line 2586 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--]);
            }
        }
    }
}

void AtEOXact_Files

(

void

)

Definition at line 2617 of file fd.c.

References CleanupTempFiles(), NULL, numTempTableSpaces, and tempTableSpaces.

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

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

static void AtProcExit_Files ( int  code, Datum  arg  )

static

Definition at line 2631 of file fd.c.

References CleanupTempFiles().

Referenced by InitFileAccess().

{
    CleanupTempFiles(true);
}

int BasicOpenFile	(	FileName	fileName,
		int	fileFlags,
		int	fileMode
	)

Definition at line 936 of file fd.c.

References ereport, errcode(), errmsg(), fd(), LOG, and ReleaseLruFile().

Referenced by AlterSystemSetConfigFile(), GetNewRelFileNode(), LruInsert(), OpenTransientFile(), PathNameOpenFile(), ReadControlFile(), UpdateControlFile(), WriteControlFile(), XLogFileInit(), XLogFileOpen(), XLogFileRead(), and XLogRead().

{
    int         fd;

tryAgain:
    fd = open(fileName, fileFlags, fileMode);

    if (fd >= 0)
        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 */
}

static void CleanupTempFiles ( bool  isProcExit )

static

Definition at line 2646 of file fd.c.

References Assert, elog, FD_TEMPORARY, FD_XACT_TEMPORARY, vfd::fdstate, FileClose(), FileIsNotOpen, FreeDesc(), have_xact_temporary_files, i, NULL, numAllocatedDescs, SizeVfdCache, and WARNING.

Referenced by AtEOXact_Files(), and AtProcExit_Files().

{
    Index       i;

    /*
     * Careful here: at proc_exit we need extra cleanup, not just
     * xact_temporary files.
     */
    if (isProcExit || have_xact_temporary_files)
    {
        Assert(FileIsNotOpen(0));   /* Make sure ring not corrupted */
        for (i = 1; i < SizeVfdCache; i++)
        {
            unsigned short fdstate = VfdCache[i].fdstate;

            if ((fdstate & FD_TEMPORARY) && VfdCache[i].fileName != NULL)
            {
                /*
                 * If we're in the process of exiting a backend process, close
                 * all temporary files. Otherwise, only close temporary files
                 * local to the current transaction. They should be closed by
                 * the ResourceOwner mechanism already, so this is just a
                 * debugging cross-check.
                 */
                if (isProcExit)
                    FileClose(i);
                else if (fdstate & FD_XACT_TEMPORARY)
                {
                    elog(WARNING,
                         "temporary file %s not closed at end-of-transaction",
                         VfdCache[i].fileName);
                    FileClose(i);
                }
            }
        }

        have_xact_temporary_files = false;
    }

    /* Clean up "allocated" stdio files, dirs and fds. */
    while (numAllocatedDescs > 0)
        FreeDesc(&allocatedDescs[0]);
}

void closeAllVfds

(

void

)

Definition at line 2499 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);
        }
    }
}

int ClosePipeStream

(

FILE *

file

)

Definition at line 2470 of file fd.c.

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

Referenced by ClosePipeToProgram(), and pg_import_system_collations().

{
    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);
}

int CloseTransientFile

(

int

fd

)

Definition at line 2305 of file fd.c.

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

Referenced by be_lo_export(), CheckPointLogicalRewriteHeap(), CheckPointReplicationOrigin(), copy_file(), dsm_impl_mmap(), durable_rename(), fsync_fname_ext(), heap_xlog_logical_rewrite(), lo_import_internal(), load_relmap_file(), mdunlinkfork(), qtext_load_file(), qtext_store(), ReadTwoPhaseFile(), RecreateTwoPhaseFile(), ReorderBufferIterTXNFinish(), ReorderBufferRestoreChanges(), ReorderBufferSerializeChange(), ReorderBufferSerializeTXN(), RestoreSlotFromDisk(), SaveSlotToPath(), SendTimeLineHistory(), SimpleLruDoesPhysicalPageExist(), SimpleLruFlush(), SlruInternalWritePage(), SlruPhysicalReadPage(), SlruPhysicalWritePage(), SnapBuildRestore(), SnapBuildSerialize(), StartupReplicationOrigin(), 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);
}

static void count_usable_fds ( int  max_to_probe, int *  usable_fds, int *  already_open  )

static

Definition at line 797 of file fd.c.

References close, elog, ereport, errmsg(), fd(), palloc(), pfree(), repalloc(), and WARNING.

Referenced by set_max_safe_fds().

{
    int        *fd;
    int         size;
    int         used = 0;
    int         highestfd = 0;
    int         j;

#ifdef HAVE_GETRLIMIT
    struct rlimit rlim;
    int         getrlimit_status;
#endif

    size = 1024;
    fd = (int *) palloc(size * sizeof(int));

#ifdef HAVE_GETRLIMIT
#ifdef RLIMIT_NOFILE            /* most platforms use RLIMIT_NOFILE */
    getrlimit_status = getrlimit(RLIMIT_NOFILE, &rlim);
#else                           /* but BSD doesn't ... */
    getrlimit_status = getrlimit(RLIMIT_OFILE, &rlim);
#endif                          /* RLIMIT_NOFILE */
    if (getrlimit_status != 0)
        ereport(WARNING, (errmsg("getrlimit failed: %m")));
#endif                          /* HAVE_GETRLIMIT */

    /* dup until failure or probe limit reached */
    for (;;)
    {
        int         thisfd;

#ifdef HAVE_GETRLIMIT

        /*
         * don't go beyond RLIMIT_NOFILE; causes irritating kernel logs on
         * some platforms
         */
        if (getrlimit_status == 0 && highestfd >= rlim.rlim_cur - 1)
            break;
#endif

        thisfd = dup(0);
        if (thisfd < 0)
        {
            /* Expect EMFILE or ENFILE, else it's fishy */
            if (errno != EMFILE && errno != ENFILE)
                elog(WARNING, "dup(0) failed after %d successes: %m", used);
            break;
        }

        if (used >= size)
        {
            size *= 2;
            fd = (int *) repalloc(fd, size * sizeof(int));
        }
        fd[used++] = thisfd;

        if (highestfd < thisfd)
            highestfd = thisfd;

        if (used >= max_to_probe)
            break;
    }

    /* release the files we opened */
    for (j = 0; j < used; j++)
        close(fd[j]);

    pfree(fd);

    /*
     * Return results.  usable_fds is just the number of successful dups. We
     * assume that the system limit is highestfd+1 (remember 0 is a legal FD
     * number) and so already_open is highestfd+1 - usable_fds.
     */
    *usable_fds = used;
    *already_open = highestfd + 1 - used;
}

static void datadir_fsync_fname ( const char *  fname, bool  isdir, int  elevel  )

static

Definition at line 3108 of file fd.c.

References fsync_fname_ext().

Referenced by SyncDataDirectory().

{
    /*
     * We want to silently ignoring errors about unreadable files.  Pass that
     * desire on to fsync_fname_ext().
     */
    fsync_fname_ext(fname, isdir, true, elevel);
}

static void Delete ( File  file )

static

Definition at line 984 of file fd.c.

References Assert, DO_DB, elog, LOG, vfd::lruLessRecently, and vfd::lruMoreRecently.

Referenced by FileAccess(), FileClose(), and LruDelete().

{
    Vfd        *vfdP;

    Assert(file != 0);

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

    vfdP = &VfdCache[file];

    VfdCache[vfdP->lruLessRecently].lruMoreRecently = vfdP->lruMoreRecently;
    VfdCache[vfdP->lruMoreRecently].lruLessRecently = vfdP->lruLessRecently;

    DO_DB(_dump_lru());
}

int durable_link_or_rename	(	const char *	oldfile,
		const char *	newfile,
		int	elevel
	)

Definition at line 712 of file fd.c.

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

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;

#if 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
    /* XXX: Add racy file existence check? */
    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;
}

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

Definition at line 593 of file fd.c.

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

Referenced by AlterSystemSetConfigFile(), CancelBackup(), CheckPointReplicationOrigin(), dir_close(), exitArchiveRecovery(), 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((char *) newfile, PG_BINARY | O_RDWR, 0);
    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;
        }
        CloseTransientFile(fd);
    }

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

int durable_unlink	(	const char *	fname,
		int	elevel
	)

Definition at line 676 of file fd.c.

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

Referenced by do_pg_stop_backup(), 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;
}

static int FileAccess ( File  file )

static

Definition at line 1250 of file fd.c.

References Delete(), DO_DB, elog, FileIsNotOpen, Insert(), LOG, and LruInsert().

Referenced by FilePrefetch(), FileRead(), FileSeek(), FileSync(), FileTruncate(), FileWrite(), and FileWriteback().

{
    int         returnValue;

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

    /*
     * Is the file open?  If not, open it and put it at the head of the LRU
     * ring (possibly closing the least recently used file to get an FD).
     */

    if (FileIsNotOpen(file))
    {
        returnValue = LruInsert(file);
        if (returnValue != 0)
            return returnValue;
    }
    else if (VfdCache[0].lruLessRecently != file)
    {
        /*
         * We now know that the file is open and that it is not the last one
         * accessed, so we need to move it to the head of the Lru ring.
         */

        Delete(file);
        Insert(file);
    }

    return 0;
}

void FileClose

(

File

file

)

Definition at line 1493 of file fd.c.

References Assert, close, Delete(), DO_DB, elog, ereport, errmsg(), vfd::fd, FD_TEMPORARY, vfd::fdstate, FileIsNotOpen, FileIsValid, vfd::fileName, vfd::fileSize, FreeVfd(), LOG, log_temp_files, nfile, pgstat_report_tempfile(), ResourceOwnerForgetFile(), vfd::resowner, temporary_files_size, unlink(), and VFD_CLOSED.

Referenced by BufFileClose(), CleanupTempFiles(), logical_end_heap_rewrite(), mdclose(), mdtruncate(), 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))
            elog(LOG, "could not close file \"%s\": %m", vfdP->fileName);

        --nfile;
        vfdP->fd = VFD_CLOSED;

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

    /*
     * Delete the file if it was temporary, and make a log entry if wanted
     */
    if (vfdP->fdstate & FD_TEMPORARY)
    {
        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_TEMPORARY;

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

        /* 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))
            elog(LOG, "could not unlink file \"%s\": %m", vfdP->fileName);

        /* and last report the stat results */
        if (stat_errno == 0)
        {
            pgstat_report_tempfile(filestats.st_size);

            if (log_temp_files >= 0)
            {
                if ((filestats.st_size / 1024) >= log_temp_files)
                    ereport(LOG,
                            (errmsg("temporary file: path \"%s\", size %lu",
                                    vfdP->fileName,
                                    (unsigned long) filestats.st_size)));
            }
        }
        else
        {
            errno = stat_errno;
            elog(LOG, "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);
}

int FileGetRawDesc

(

File

file

)

Definition at line 1990 of file fd.c.

References Assert, vfd::fd, and FileIsValid.

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

int FileGetRawFlags

(

File

file

)

Definition at line 2000 of file fd.c.

References Assert, vfd::fileFlags, and FileIsValid.

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

int FileGetRawMode

(

File

file

)

Definition at line 2010 of file fd.c.

References Assert, FileIsValid, and vfd::fileMode.

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

char* FilePathName

(

File

file

)

Definition at line 1974 of file fd.c.

References Assert, FileIsValid, and vfd::fileName.

Referenced by _mdnblocks(), mdextend(), mdimmedsync(), mdread(), mdsync(), mdtruncate(), mdwrite(), and register_dirty_segment().

{
    Assert(FileIsValid(file));

    return VfdCache[file].fileName;
}

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

Definition at line 1590 of file fd.c.

References Assert, DO_DB, elog, fd(), FileAccess(), FileIsValid, 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
}

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

Definition at line 1645 of file fd.c.

References _dosmaperr(), Assert, DO_DB, EINTR, elog, error(), vfd::fd, FileAccess(), FileIsValid, FilePosIsUnknown, FileUnknownPos, INT64_FORMAT, LOG, pg_usleep(), pgstat_report_wait_end(), pgstat_report_wait_start(), read, and vfd::seekPos.

Referenced by BufFileLoadBuffer(), and mdread().

{
    int         returnCode;
    Vfd        *vfdP;

    Assert(FileIsValid(file));

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

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

    vfdP = &VfdCache[file];

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

    if (returnCode >= 0)
    {
        /* if seekPos is unknown, leave it that way */
        if (!FilePosIsUnknown(vfdP->seekPos))
            vfdP->seekPos += returnCode;
    }
    else
    {
        /*
         * 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;

        /* Trouble, so assume we don't know the file position anymore */
        vfdP->seekPos = FileUnknownPos;
    }

    return returnCode;
}

off_t FileSeek	(	File	file,
		off_t	offset,
		int	whence
	)

Definition at line 1851 of file fd.c.

References Assert, DO_DB, elog, ERROR, vfd::fd, FileAccess(), FileIsNotOpen, FileIsValid, FilePosIsUnknown, INT64_FORMAT, LOG, and vfd::seekPos.

Referenced by _mdnblocks(), BufFileDumpBuffer(), BufFileLoadBuffer(), mdextend(), mdread(), and mdwrite().

{
    Vfd        *vfdP;

    Assert(FileIsValid(file));

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

    vfdP = &VfdCache[file];

    if (FileIsNotOpen(file))
    {
        switch (whence)
        {
            case SEEK_SET:
                if (offset < 0)
                {
                    errno = EINVAL;
                    return (off_t) -1;
                }
                vfdP->seekPos = offset;
                break;
            case SEEK_CUR:
                if (FilePosIsUnknown(vfdP->seekPos) ||
                    vfdP->seekPos + offset < 0)
                {
                    errno = EINVAL;
                    return (off_t) -1;
                }
                vfdP->seekPos += offset;
                break;
            case SEEK_END:
                if (FileAccess(file) < 0)
                    return (off_t) -1;
                vfdP->seekPos = lseek(vfdP->fd, offset, whence);
                break;
            default:
                elog(ERROR, "invalid whence: %d", whence);
                break;
        }
    }
    else
    {
        switch (whence)
        {
            case SEEK_SET:
                if (offset < 0)
                {
                    errno = EINVAL;
                    return (off_t) -1;
                }
                if (vfdP->seekPos != offset)
                    vfdP->seekPos = lseek(vfdP->fd, offset, whence);
                break;
            case SEEK_CUR:
                if (offset != 0 || FilePosIsUnknown(vfdP->seekPos))
                    vfdP->seekPos = lseek(vfdP->fd, offset, whence);
                break;
            case SEEK_END:
                vfdP->seekPos = lseek(vfdP->fd, offset, whence);
                break;
            default:
                elog(ERROR, "invalid whence: %d", whence);
                break;
        }
    }

    return vfdP->seekPos;
}

int FileSync	(	File	file,
		uint32	wait_event_info
	)

Definition at line 1830 of file fd.c.

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

Referenced by logical_end_heap_rewrite(), mdimmedsync(), mdsync(), 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;
}

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

Definition at line 1939 of file fd.c.

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

Referenced by 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_TEMPORARY);
        temporary_files_size -= VfdCache[file].fileSize - offset;
        VfdCache[file].fileSize = offset;
    }

    return returnCode;
}

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

Definition at line 1709 of file fd.c.

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

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) VfdCache[file].seekPos,
               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_TEMPORARY))
    {
        off_t       newPos;

        /*
         * Normally we should know the seek position, but if for some reason
         * we have lost track of it, try again to get it.  Here, it's fine to
         * throw an error if we still can't get it.
         */
        if (FilePosIsUnknown(vfdP->seekPos))
        {
            vfdP->seekPos = lseek(vfdP->fd, (off_t) 0, SEEK_CUR);
            if (FilePosIsUnknown(vfdP->seekPos))
                elog(ERROR, "could not seek file \"%s\": %m", vfdP->fileName);
        }

        newPos = vfdP->seekPos + amount;
        if (newPos > vfdP->fileSize)
        {
            uint64      newTotal = temporary_files_size;

            newTotal += newPos - 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 = write(vfdP->fd, buffer, amount);
    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)
    {
        /* if seekPos is unknown, leave it that way */
        if (!FilePosIsUnknown(vfdP->seekPos))
            vfdP->seekPos += returnCode;

        /*
         * Maintain fileSize and temporary_files_size if it's a temp file.
         *
         * If seekPos is -1 (unknown), this will do nothing; but we could only
         * get here in that state if we're not enforcing temporary_files_size,
         * so we don't care.
         */
        if (vfdP->fdstate & FD_TEMPORARY)
        {
            off_t       newPos = vfdP->seekPos;

            if (newPos > vfdP->fileSize)
            {
                temporary_files_size += newPos - vfdP->fileSize;
                vfdP->fileSize = newPos;
            }
        }
    }
    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;

        /* Trouble, so assume we don't know the file position anymore */
        vfdP->seekPos = FileUnknownPos;
    }

    return returnCode;
}

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

Definition at line 1618 of file fd.c.

References Assert, DO_DB, elog, fd(), FileAccess(), FileIsValid, 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));

    /*
     * Caution: do not call pg_flush_data with nbytes = 0, it could trash the
     * file's seek position.  We prefer to define that as a no-op here.
     */
    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();
}

static int FreeDesc ( AllocateDesc *  desc )

static

Definition at line 2238 of file fd.c.

References AllocateDescDir, AllocateDescFile, AllocateDescPipe, AllocateDescRawFD, close, closedir(), AllocateDesc::desc, AllocateDesc::dir, elog, ERROR, AllocateDesc::fd, AllocateDesc::file, AllocateDesc::kind, numAllocatedDescs, and result.

Referenced by AtEOSubXact_Files(), CleanupTempFiles(), ClosePipeStream(), CloseTransientFile(), FreeDir(), and FreeFile().

{
    int         result;

    /* Close the underlying object */
    switch (desc->kind)
    {
        case AllocateDescFile:
            result = fclose(desc->desc.file);
            break;
        case AllocateDescPipe:
            result = pclose(desc->desc.file);
            break;
        case AllocateDescDir:
            result = closedir(desc->desc.dir);
            break;
        case AllocateDescRawFD:
            result = close(desc->desc.fd);
            break;
        default:
            elog(ERROR, "AllocateDesc kind not recognized");
            result = 0;         /* keep compiler quiet */
            break;
    }

    /* Compact storage in the allocatedDescs array */
    numAllocatedDescs--;
    *desc = allocatedDescs[numAllocatedDescs];

    return result;
}

int FreeDir

(

DIR *

dir

)

Definition at line 2444 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(), dsm_cleanup_for_mmap(), get_ext_ver_list(), getInstallationPaths(), movedb(), ParseTzFile(), perform_base_backup(), pg_available_extension_versions(), pg_available_extensions(), pg_logdir_ls(), pg_ls_dir(), pg_ls_dir_files(), pg_start_backup(), pg_tablespace_databases(), pg_tzenumerate_end(), pg_tzenumerate_next(), pgarch_readyXlog(), pgstat_reset_remove_files(), RelationCacheInitFileRemove(), RelationCacheInitFileRemoveInDir(), RemoveNonParentXlogFiles(), RemoveOldXlogFiles(), RemovePgTempFiles(), RemovePgTempFilesInDir(), RemovePgTempRelationFiles(), RemovePgTempRelationFilesInDbspace(), ResetUnloggedRelations(), ResetUnloggedRelationsInDbspaceDir(), ResetUnloggedRelationsInTablespaceDir(), restoreTwoPhaseData(), scan_directory_ci(), SendBaseBackup(), sendDir(), SlruScanDirectory(), StartupReorderBuffer(), StartupReplicationSlots(), UpdateLogicalMappings(), and walkdir().

{
    int         i;

    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);
}

int FreeFile

(

FILE *

file

)

Definition at line 2277 of file fd.c.

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

Referenced by AlterSystemSetConfigFile(), checkDataDir(), do_pg_start_backup(), do_pg_stop_backup(), EndCopy(), entry_reset(), existsTimeLineHistory(), ExportSnapshot(), fill_hba_view(), gc_qtexts(), ImportSnapshot(), load_hba(), load_ident(), load_relcache_init_file(), parse_extension_control_file(), ParseTzFile(), perform_base_backup(), pg_backup_start_time(), pg_current_logfile(), pg_file_write(), 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(), read_backup_label(), read_binary_file(), read_tablespace_map(), read_whole_file(), readRecoveryCommandFile(), readTimeLineHistory(), sendFile(), 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);
}

static void FreeVfd ( File  file )

static

Definition at line 1230 of file fd.c.

References DO_DB, elog, vfd::fdstate, vfd::fileName, free, LOG, vfd::nextFree, and NULL.

Referenced by FileClose(), and PathNameOpenFile().

{
    Vfd        *vfdP = &VfdCache[file];

    DO_DB(elog(LOG, "FreeVfd: %d (%s)",
               file, vfdP->fileName ? vfdP->fileName : ""));

    if (vfdP->fileName != NULL)
    {
        free(vfdP->fileName);
        vfdP->fileName = NULL;
    }
    vfdP->fdstate = 0x0;

    vfdP->nextFree = VfdCache[0].nextFree;
    VfdCache[0].nextFree = file;
}

void fsync_fname	(	const char *	fname,
		bool	isdir
	)

Definition at line 567 of file fd.c.

References ERROR, and fsync_fname_ext().

Referenced by _CloseArchive(), BaseBackup(), CheckPointCLOG(), CheckPointCommitTs(), CheckPointTwoPhase(), copydir(), CreateSlotOnDisk(), dir_close(), dir_finish(), dir_open_for_write(), main(), ReceiveTarFile(), ReplicationSlotDropPtr(), ResetUnloggedRelationsInDbspaceDir(), RestoreSlotFromDisk(), SaveSlotToPath(), ShutdownCLOG(), ShutdownCommitTs(), SnapBuildRestore(), SnapBuildSerialize(), StartupReplicationSlots(), and tar_finish().

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

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

static

Definition at line 3126 of file fd.c.

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

Referenced by datadir_fsync_fname(), durable_link_or_rename(), durable_rename(), fsync_fname(), and fsync_parent_path().

{
    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((char *) fname, flags, 0);

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

    (void) CloseTransientFile(fd);

    return 0;
}

static int fsync_parent_path ( const char *  fname, int  elevel  )

static

Definition at line 3196 of file fd.c.

References fsync_fname_ext(), get_parent_directory(), MAXPGPATH, and strlcpy().

Referenced by dir_close(), dir_open_for_write(), durable_link_or_rename(), durable_rename(), durable_unlink(), and tar_finish().

{
    char        parentpath[MAXPGPATH];

    strlcpy(parentpath, fname, MAXPGPATH);
    get_parent_directory(parentpath);

    /*
     * get_parent_directory() returns an empty string if the input argument is
     * just a file name (see comments in path.c), so handle that as being the
     * current directory.
     */
    if (strlen(parentpath) == 0)
        strlcpy(parentpath, ".", MAXPGPATH);

    if (fsync_fname_ext(parentpath, true, false, elevel) != 0)
        return -1;

    return 0;
}

Oid GetNextTempTableSpace

(

void

)

Definition at line 2565 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;
}

void InitFileAccess

(

void

)

Definition at line 764 of file fd.c.

References Assert, AtProcExit_Files(), ereport, errcode(), errmsg(), FATAL, vfd::fd, malloc, MemSet, NULL, 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);
}

static void Insert ( File  file )

static

Definition at line 1044 of file fd.c.

References Assert, DO_DB, elog, LOG, vfd::lruLessRecently, and vfd::lruMoreRecently.

Referenced by AdvanceXLInsertBuffer(), CreateCheckPoint(), FileAccess(), GetXLogInsertRecPtr(), InitXLOGAccess(), LruInsert(), PathNameOpenFile(), ReserveXLogInsertLocation(), ReserveXLogSwitch(), StartupXLOG(), UpdateFullPageWrites(), WaitXLogInsertionsToFinish(), and XLogInsertRecord().

{
    Vfd        *vfdP;

    Assert(file != 0);

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

    vfdP = &VfdCache[file];

    vfdP->lruMoreRecently = 0;
    vfdP->lruLessRecently = VfdCache[0].lruLessRecently;
    VfdCache[0].lruLessRecently = file;
    VfdCache[vfdP->lruLessRecently].lruMoreRecently = file;

    DO_DB(_dump_lru());
}

static bool looks_like_temp_rel_name ( const char *  name )

static

Definition at line 2866 of file fd.c.

References forkname_chars(), and NULL.

Referenced by RemovePgTempRelationFilesInDbspace().

{
    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;
}

static void LruDelete ( File  file )

static

Definition at line 1003 of file fd.c.

References Assert, close, Delete(), DO_DB, elog, vfd::fd, vfd::fileName, FilePosIsUnknown, LOG, nfile, vfd::seekPos, and VFD_CLOSED.

Referenced by closeAllVfds(), and ReleaseLruFile().

{
    Vfd        *vfdP;

    Assert(file != 0);

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

    vfdP = &VfdCache[file];

    /*
     * Normally we should know the seek position, but if for some reason we
     * have lost track of it, try again to get it.  If we still can't get it,
     * we have a problem: we will be unable to restore the file seek position
     * when and if the file is re-opened.  But we can't really throw an error
     * and refuse to close the file, or activities such as transaction cleanup
     * will be broken.
     */
    if (FilePosIsUnknown(vfdP->seekPos))
    {
        vfdP->seekPos = lseek(vfdP->fd, (off_t) 0, SEEK_CUR);
        if (FilePosIsUnknown(vfdP->seekPos))
            elog(LOG, "could not seek file \"%s\" before closing: %m",
                 vfdP->fileName);
    }

    /*
     * Close the file.  We aren't expecting this to fail; if it does, better
     * to leak the FD than to mess up our internal state.
     */
    if (close(vfdP->fd))
        elog(LOG, "could not close file \"%s\": %m", vfdP->fileName);
    vfdP->fd = VFD_CLOSED;
    --nfile;

    /* delete the vfd record from the LRU ring */
    Delete(file);
}

static int LruInsert ( File  file )

static

Definition at line 1066 of file fd.c.

References Assert, BasicOpenFile(), close, DO_DB, elog, vfd::fd, vfd::fileFlags, FileIsNotOpen, vfd::fileMode, vfd::fileName, Insert(), LOG, nfile, ReleaseLruFiles(), vfd::seekPos, and VFD_CLOSED.

Referenced by FileAccess().

{
    Vfd        *vfdP;

    Assert(file != 0);

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

    vfdP = &VfdCache[file];

    if (FileIsNotOpen(file))
    {
        /* Close excess kernel FDs. */
        ReleaseLruFiles();

        /*
         * The open could still fail for lack of file descriptors, eg due to
         * overall system file table being full.  So, be prepared to release
         * another FD if necessary...
         */
        vfdP->fd = BasicOpenFile(vfdP->fileName, vfdP->fileFlags,
                                 vfdP->fileMode);
        if (vfdP->fd < 0)
        {
            DO_DB(elog(LOG, "re-open failed: %m"));
            return -1;
        }
        else
        {
            ++nfile;
        }

        /*
         * Seek to the right position.  We need no special case for seekPos
         * equal to FileUnknownPos, as lseek() will certainly reject that
         * (thus completing the logic noted in LruDelete() that we will fail
         * to re-open a file if we couldn't get its seek position before
         * closing).
         */
        if (vfdP->seekPos != (off_t) 0)
        {
            if (lseek(vfdP->fd, vfdP->seekPos, SEEK_SET) < 0)
            {
                /*
                 * If we fail to restore the seek position, treat it like an
                 * open() failure.
                 */
                int         save_errno = errno;

                elog(LOG, "could not seek file \"%s\" after re-opening: %m",
                     vfdP->fileName);
                (void) close(vfdP->fd);
                vfdP->fd = VFD_CLOSED;
                --nfile;
                errno = save_errno;
                return -1;
            }
        }
    }

    /*
     * put it at the head of the Lru ring
     */

    Insert(file);

    return 0;
}

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

Definition at line 2184 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, NULL, numAllocatedDescs, ReleaseLruFile(), ReleaseLruFiles(), and reserveAllocatedDesc().

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

{
    FILE       *file;

    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);
    errno = 0;
    if ((file = popen(command, mode)) != 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)
    {
        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;
}

File OpenTemporaryFile

(

bool

interXact

)

Definition at line 1371 of file fd.c.

References CurrentResourceOwner, DEFAULTTABLESPACE_OID, FD_TEMPORARY, FD_XACT_TEMPORARY, vfd::fdstate, GetNextTempTableSpace(), have_xact_temporary_files, MyDatabaseTableSpace, numTempTableSpaces, OidIsValid, OpenTemporaryFileInTablespace(), ResourceOwnerEnlargeFiles(), ResourceOwnerRememberFile(), and vfd::resowner.

Referenced by BufFileCreateTemp(), and extendBufFile().

{
    File        file = 0;

    /*
     * 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 */
    VfdCache[file].fdstate |= FD_TEMPORARY;

    /* Register it with the current resource owner */
    if (!interXact)
    {
        VfdCache[file].fdstate |= FD_XACT_TEMPORARY;

        ResourceOwnerEnlargeFiles(CurrentResourceOwner);
        ResourceOwnerRememberFile(CurrentResourceOwner, file);
        VfdCache[file].resowner = CurrentResourceOwner;

        /* ensure cleanup happens at eoxact */
        have_xact_temporary_files = true;
    }

    return file;
}

static File OpenTemporaryFileInTablespace ( Oid  tblspcOid, bool  rejectError  )

static

Definition at line 1427 of file fd.c.

References DEFAULTTABLESPACE_OID, elog, ERROR, GLOBALTABLESPACE_OID, MAXPGPATH, mkdir, MyProcPid, PathNameOpenFile(), PG_BINARY, PG_TEMP_FILE_PREFIX, PG_TEMP_FILES_DIR, snprintf(), TABLESPACE_VERSION_DIRECTORY, and tempFileCounter.

Referenced by OpenTemporaryFile().

{
    char        tempdirpath[MAXPGPATH];
    char        tempfilepath[MAXPGPATH];
    File        file;

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

    /*
     * Generate a tempfile name that should be unique within the current
     * database instance.
     */
    snprintf(tempfilepath, sizeof(tempfilepath), "%s/%s%d.%ld",
             tempdirpath, PG_TEMP_FILE_PREFIX, MyProcPid, tempFileCounter++);

    /*
     * Open the file.  Note: we don't use O_EXCL, in case there is an orphaned
     * temp file that can be reused.
     */
    file = PathNameOpenFile(tempfilepath,
                            O_RDWR | O_CREAT | O_TRUNC | PG_BINARY,
                            0600);
    if (file <= 0)
    {
        /*
         * We might need to create the tablespace's tempfile directory, if no
         * one has yet done so.
         *
         * Don't check for error from mkdir; it could fail if someone else
         * just did the same thing.  If it doesn't work then we'll bomb out on
         * the second create attempt, instead.
         */
        mkdir(tempdirpath, S_IRWXU);

        file = PathNameOpenFile(tempfilepath,
                                O_RDWR | O_CREAT | O_TRUNC | PG_BINARY,
                                0600);
        if (file <= 0 && rejectError)
            elog(ERROR, "could not create temporary file \"%s\": %m",
                 tempfilepath);
    }

    return file;
}

int OpenTransientFile	(	FileName	fileName,
		int	fileFlags,
		int	fileMode
	)

Definition at line 2144 of file fd.c.

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

Referenced by ApplyLogicalMappingFile(), be_lo_export(), CheckPointLogicalRewriteHeap(), CheckPointReplicationOrigin(), copy_file(), dsm_impl_mmap(), durable_rename(), fsync_fname_ext(), heap_xlog_logical_rewrite(), lo_import_internal(), load_relmap_file(), mdunlinkfork(), qtext_load_file(), qtext_store(), ReadTwoPhaseFile(), RecreateTwoPhaseFile(), ReorderBufferRestoreChanges(), ReorderBufferSerializeTXN(), RestoreSlotFromDisk(), SaveSlotToPath(), SendTimeLineHistory(), SimpleLruDoesPhysicalPageExist(), SlruPhysicalReadPage(), SlruPhysicalWritePage(), SnapBuildRestore(), SnapBuildSerialize(), StartupReplicationOrigin(), write_relmap_file(), writeTimeLineHistory(), writeTimeLineHistoryFile(), and XLogFileCopy().

{
    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 = BasicOpenFile(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 */
}

File PathNameOpenFile	(	FileName	fileName,
		int	fileFlags,
		int	fileMode
	)

Definition at line 1303 of file fd.c.

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

Referenced by _mdfd_openseg(), logical_rewrite_log_mapping(), mdcreate(), mdopen(), and OpenTemporaryFileInTablespace().

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

    DO_DB(elog(LOG, "PathNameOpenFile: %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 = BasicOpenFile(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));

    Insert(file);

    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->seekPos = 0;
    vfdP->fileSize = 0;
    vfdP->fdstate = 0x0;
    vfdP->resowner = NULL;

    return file;
}

int pg_fdatasync

(

int

fd

)

Definition at line 385 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;
}

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

Definition at line 407 of file fd.c.

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

Referenced by copy_file(), and FileWriteback().

{
    /*
     * 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;

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

        /* don't error out, this is just a performance optimization */
        if (rc != 0)
        {
            ereport(WARNING,
                    (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(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
}

int pg_fsync

(

int

fd

)

Definition at line 333 of file fd.c.

References pg_fsync_no_writethrough(), pg_fsync_writethrough(), 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(), RecreateTwoPhaseFile(), RestoreSlotFromDisk(), SaveSlotToPath(), SimpleLruFlush(), SlruPhysicalWritePage(), SnapBuildSerialize(), UpdateControlFile(), write_auto_conf_file(), write_relmap_file(), WriteControlFile(), writeTimeLineHistory(), writeTimeLineHistoryFile(), XLogFileCopy(), and XLogFileInit().

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

int pg_fsync_no_writethrough

(

int

fd

)

Definition at line 350 of file fd.c.

References enableFsync, and fsync.

Referenced by issue_xlog_fsync(), and pg_fsync().

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

int pg_fsync_writethrough

(

int

fd

)

Definition at line 362 of file fd.c.

References enableFsync.

Referenced by issue_xlog_fsync(), pg_fsync(), 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;
}

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

Definition at line 2401 of file fd.c.

References ERROR, and ReadDirExtended().

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(), get_ext_ver_list(), movedb(), perform_base_backup(), pg_available_extension_versions(), pg_available_extensions(), pg_logdir_ls(), pg_ls_dir(), pg_ls_dir_files(), pg_tablespace_databases(), pg_tzenumerate_next(), pgarch_readyXlog(), pgstat_reset_remove_files(), RelationCacheInitFileRemove(), RelationCacheInitFileRemoveInDir(), RemoveNonParentXlogFiles(), RemoveOldXlogFiles(), RemovePgTempFiles(), RemovePgTempFilesInDir(), RemovePgTempRelationFiles(), RemovePgTempRelationFilesInDbspace(), ResetUnloggedRelations(), ResetUnloggedRelationsInDbspaceDir(), ResetUnloggedRelationsInTablespaceDir(), restoreTwoPhaseData(), scan_directory_ci(), sendDir(), SlruScanDirectory(), StartupReorderBuffer(), StartupReplicationSlots(), and UpdateLogicalMappings().

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

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

static

Definition at line 2411 of file fd.c.

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

Referenced by ReadDir(), 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;
}

static bool ReleaseLruFile ( void  )

static

Definition at line 1140 of file fd.c.

References Assert, DO_DB, elog, LOG, LruDelete(), and nfile.

Referenced by AllocateDir(), AllocateFile(), BasicOpenFile(), OpenPipeStream(), and ReleaseLruFiles().

{
    DO_DB(elog(LOG, "ReleaseLruFile. Opened %d", nfile));

    if (nfile > 0)
    {
        /*
         * There are opened files and so there should be at least one used vfd
         * in the ring.
         */
        Assert(VfdCache[0].lruMoreRecently != 0);
        LruDelete(VfdCache[0].lruMoreRecently);
        return true;            /* freed a file */
    }
    return false;               /* no files available to free */
}

static void ReleaseLruFiles ( void  )

static

Definition at line 1162 of file fd.c.

References max_safe_fds, nfile, numAllocatedDescs, and ReleaseLruFile().

Referenced by AllocateDir(), AllocateFile(), LruInsert(), OpenPipeStream(), OpenTransientFile(), and PathNameOpenFile().

{
    while (nfile + numAllocatedDescs >= max_safe_fds)
    {
        if (!ReleaseLruFile())
            break;
    }
}

void RemovePgTempFiles

(

void

)

Definition at line 2706 of file fd.c.

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

Referenced by PostmasterMain().

{
    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);
    RemovePgTempRelationFiles("base");

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

    while ((spc_de = ReadDir(spc_dir, "pg_tblspc")) != 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);

        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.
     */
#ifdef EXEC_BACKEND
    RemovePgTempFilesInDir(PG_TEMP_FILES_DIR);
#endif
}

static void RemovePgTempFilesInDir ( const char *  tmpdirname )

static

Definition at line 2752 of file fd.c.

References AllocateDir(), dirent::d_name, elog, FreeDir(), LOG, MAXPGPATH, NULL, PG_TEMP_FILE_PREFIX, ReadDir(), snprintf(), and unlink().

Referenced by RemovePgTempFiles().

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

    temp_dir = AllocateDir(tmpdirname);
    if (temp_dir == NULL)
    {
        /* anything except ENOENT is fishy */
        if (errno != ENOENT)
            elog(LOG,
                 "could not open temporary-files directory \"%s\": %m",
                 tmpdirname);
        return;
    }

    while ((temp_de = ReadDir(temp_dir, tmpdirname)) != 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 (strncmp(temp_de->d_name,
                    PG_TEMP_FILE_PREFIX,
                    strlen(PG_TEMP_FILE_PREFIX)) == 0)
            unlink(rm_path);    /* note we ignore any error */
        else
            elog(LOG,
                 "unexpected file found in temporary-files directory: \"%s\"",
                 rm_path);
    }

    FreeDir(temp_dir);
}

static void RemovePgTempRelationFiles ( const char *  tsdirname )

static

Definition at line 2793 of file fd.c.

References AllocateDir(), dirent::d_name, elog, FreeDir(), i, LOG, MAXPGPATH, NULL, ReadDir(), RemovePgTempRelationFilesInDbspace(), and snprintf().

Referenced by RemovePgTempFiles().

{
    DIR        *ts_dir;
    struct dirent *de;
    char        dbspace_path[MAXPGPATH * 2];

    ts_dir = AllocateDir(tsdirname);
    if (ts_dir == NULL)
    {
        /* anything except ENOENT is fishy */
        if (errno != ENOENT)
            elog(LOG,
                 "could not open tablespace directory \"%s\": %m",
                 tsdirname);
        return;
    }

    while ((de = ReadDir(ts_dir, tsdirname)) != NULL)
    {
        int         i = 0;

        /*
         * We're only interested in the per-database directories, which have
         * numeric names.  Note that this code will also (properly) ignore "."
         * and "..".
         */
        while (isdigit((unsigned char) de->d_name[i]))
            ++i;
        if (de->d_name[i] != '\0' || i == 0)
            continue;

        snprintf(dbspace_path, sizeof(dbspace_path), "%s/%s",
                 tsdirname, de->d_name);
        RemovePgTempRelationFilesInDbspace(dbspace_path);
    }

    FreeDir(ts_dir);
}

static void RemovePgTempRelationFilesInDbspace ( const char *  dbspacedirname )

static

Definition at line 2834 of file fd.c.

References AllocateDir(), dirent::d_name, elog, FreeDir(), LOG, looks_like_temp_rel_name(), MAXPGPATH, NULL, ReadDir(), snprintf(), and unlink().

Referenced by RemovePgTempRelationFiles().

{
    DIR        *dbspace_dir;
    struct dirent *de;
    char        rm_path[MAXPGPATH * 2];

    dbspace_dir = AllocateDir(dbspacedirname);
    if (dbspace_dir == NULL)
    {
        /* we just saw this directory, so it really ought to be there */
        elog(LOG,
             "could not open dbspace directory \"%s\": %m",
             dbspacedirname);
        return;
    }

    while ((de = ReadDir(dbspace_dir, dbspacedirname)) != NULL)
    {
        if (!looks_like_temp_rel_name(de->d_name))
            continue;

        snprintf(rm_path, sizeof(rm_path), "%s/%s",
                 dbspacedirname, de->d_name);

        unlink(rm_path);        /* note we ignore any error */
    }

    FreeDir(dbspace_dir);
}

static bool reserveAllocatedDesc ( void  )

static

Definition at line 2021 of file fd.c.

References ereport, errcode(), errmsg(), ERROR, FD_MINFREE, malloc, max_safe_fds, maxAllocatedDescs, NULL, numAllocatedDescs, and realloc.

Referenced by AllocateDir(), AllocateFile(), OpenPipeStream(), and OpenTransientFile().

{
    AllocateDesc *newDescs;
    int         newMax;

    /* Quick out if array already has a free slot. */
    if (numAllocatedDescs < maxAllocatedDescs)
        return true;

    /*
     * If the array hasn't yet been created in the current process, initialize
     * it with FD_MINFREE / 2 elements.  In many scenarios this is as many as
     * we will ever need, anyway.  We don't want to look at max_safe_fds
     * immediately because set_max_safe_fds() may not have run yet.
     */
    if (allocatedDescs == NULL)
    {
        newMax = FD_MINFREE / 2;
        newDescs = (AllocateDesc *) malloc(newMax * sizeof(AllocateDesc));
        /* Out of memory already?  Treat as fatal error. */
        if (newDescs == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_OUT_OF_MEMORY),
                     errmsg("out of memory")));
        allocatedDescs = newDescs;
        maxAllocatedDescs = newMax;
        return true;
    }

    /*
     * Consider enlarging the array beyond the initial allocation used above.
     * By the time this happens, max_safe_fds should be known accurately.
     *
     * We mustn't let allocated descriptors hog all the available FDs, and in
     * practice we'd better leave a reasonable number of FDs for VFD use.  So
     * set the maximum to max_safe_fds / 2.  (This should certainly be at
     * least as large as the initial size, FD_MINFREE / 2.)
     */
    newMax = max_safe_fds / 2;
    if (newMax > maxAllocatedDescs)
    {
        newDescs = (AllocateDesc *) realloc(allocatedDescs,
                                            newMax * sizeof(AllocateDesc));
        /* Treat out-of-memory as a non-fatal error. */
        if (newDescs == NULL)
            return false;
        allocatedDescs = newDescs;
        maxAllocatedDescs = newMax;
        return true;
    }

    /* Can't enlarge allocatedDescs[] any more. */
    return false;
}

void set_max_safe_fds

(

void

)

Definition at line 881 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);
}

void SetTempTablespaces	(	Oid *	tableSpaces,
		int	numSpaces
	)

Definition at line 2525 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;
}

void SyncDataDirectory

(

void

)

Definition at line 2933 of file fd.c.

References datadir_fsync_fname(), DEBUG1, enableFsync, ereport, errcode_for_file_access(), errmsg(), LOG, lstat, 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

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

bool TempTablespacesAreSet

(

void

)

Definition at line 2553 of file fd.c.

References numTempTableSpaces.

Referenced by PrepareTempTablespaces().

{
    return (numTempTableSpaces >= 0);
}

static void walkdir ( const char *  path, void(*)(const char *fname, bool isdir, int elevel)  action, bool  process_symlinks, int  elevel  )

static

Definition at line 3006 of file fd.c.

References AllocateDir(), CHECK_FOR_INTERRUPTS, dirent::d_name, elevel, ereport, errcode_for_file_access(), errmsg(), FreeDir(), lstat, MAXPGPATH, NULL, ReadDirExtended(), snprintf(), and subpath().

Referenced by SyncDataDirectory().

{
    DIR        *dir;
    struct dirent *de;

    dir = AllocateDir(path);
    if (dir == NULL)
    {
        ereport(elevel,
                (errcode_for_file_access(),
                 errmsg("could not open directory \"%s\": %m", path)));
        return;
    }

    while ((de = ReadDirExtended(dir, path, elevel)) != NULL)
    {
        char        subpath[MAXPGPATH * 2];
        struct stat fst;
        int         sret;

        CHECK_FOR_INTERRUPTS();

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

        snprintf(subpath, sizeof(subpath), "%s/%s", path, de->d_name);

        if (process_symlinks)
            sret = stat(subpath, &fst);
        else
            sret = lstat(subpath, &fst);

        if (sret < 0)
        {
            ereport(elevel,
                    (errcode_for_file_access(),
                     errmsg("could not stat file \"%s\": %m", subpath)));
            continue;
        }

        if (S_ISREG(fst.st_mode))
            (*action) (subpath, false, elevel);
        else if (S_ISDIR(fst.st_mode))
            walkdir(subpath, action, false, elevel);
    }

    FreeDir(dir);               /* we ignore any error here */

    /*
     * It's important to fsync the destination directory itself as individual
     * file fsyncs don't guarantee that the directory entry for the file is
     * synced.
     */
    (*action) (path, true, elevel);
}

Variable Documentation

AllocateDesc* allocatedDescs = NULL

static

Definition at line 245 of file fd.c.

bool have_xact_temporary_files = false

static

Definition at line 209 of file fd.c.

Referenced by CleanupTempFiles(), and OpenTemporaryFile().

int max_files_per_process = 1000

Definition at line 126 of file fd.c.

Referenced by set_max_safe_fds().

int max_safe_fds = 32

Definition at line 139 of file fd.c.

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

int maxAllocatedDescs = 0

static

Definition at line 244 of file fd.c.

Referenced by AllocateDir(), AllocateFile(), OpenPipeStream(), OpenTransientFile(), and reserveAllocatedDesc().

int nextTempTableSpace = 0

static

Definition at line 259 of file fd.c.

Referenced by GetNextTempTableSpace(), and SetTempTablespaces().

int nfile = 0

static

Definition at line 203 of file fd.c.

Referenced by FileClose(), LruDelete(), LruInsert(), PathNameOpenFile(), ReleaseLruFile(), and ReleaseLruFiles().

int numAllocatedDescs = 0

static

Definition at line 243 of file fd.c.

Referenced by AllocateDir(), AllocateFile(), AtEOSubXact_Files(), CleanupTempFiles(), ClosePipeStream(), CloseTransientFile(), FreeDesc(), FreeDir(), FreeFile(), OpenPipeStream(), OpenTransientFile(), ReleaseLruFiles(), and reserveAllocatedDesc().

int numTempTableSpaces = -1

static

Definition at line 258 of file fd.c.

Referenced by AtEOXact_Files(), GetNextTempTableSpace(), OpenTemporaryFile(), SetTempTablespaces(), and TempTablespacesAreSet().

Size SizeVfdCache = 0

static

Definition at line 198 of file fd.c.

Referenced by AllocateVfd(), CleanupTempFiles(), closeAllVfds(), and InitFileAccess().

long tempFileCounter = 0

static

Definition at line 251 of file fd.c.

Referenced by OpenTemporaryFileInTablespace().

uint64 temporary_files_size = 0

static

Definition at line 217 of file fd.c.

Referenced by FileClose(), FileTruncate(), and FileWrite().

Oid* tempTableSpaces = NULL

static

Definition at line 257 of file fd.c.

Referenced by AtEOXact_Files(), GetNextTempTableSpace(), and SetTempTablespaces().

Vfd* VfdCache

static

Definition at line 197 of file fd.c.