#include "postgres.h"
#include <dirent.h>
#include <sys/file.h>
#include <sys/param.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <limits.h>
#include <unistd.h>
#include <fcntl.h>
#include "access/xact.h"
#include "access/xlog.h"
#include "catalog/pg_tablespace.h"
#include "common/file_perm.h"
#include "common/file_utils.h"
#include "common/pg_prng.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "portability/mem.h"
#include "postmaster/startup.h"
#include "storage/fd.h"
#include "storage/ipc.h"
#include "utils/guc.h"
#include "utils/guc_hooks.h"
#include "utils/resowner_private.h"
#include "utils/varlena.h"

Include dependency graph for fd.c:

Data Structures
struct	vfd

struct	AllocateDesc

Macros
#define	NUM_RESERVED_FDS 10

#define	FD_MINFREE 48

#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	FD_DELETE_AT_CLOSE (1 << 0) /* T = delete when closed */

#define	FD_CLOSE_AT_EOXACT (1 << 1) /* T = close at eoXact */

#define	FD_TEMP_FILE_LIMIT (1 << 2) /* T = respect temp_file_limit */

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 void	BeforeShmemExit_Files (int code, Datum arg)

static void	CleanupTempFiles (bool isCommit, bool isProcExit)

static void	RemovePgTempRelationFiles (const char *tsdirname)

static void	RemovePgTempRelationFilesInDbspace (const char *dbspacedirname)

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 void	unlink_if_exists_fname (const char *fname, bool isdir, 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)

static int	pg_ftruncate (int fd, off_t length)

int	pg_truncate (const char *path, off_t length)

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)

void	InitFileAccess (void)

void	InitTemporaryFileAccess (void)

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

void	set_max_safe_fds (void)

int	BasicOpenFile (const char *fileName, int fileFlags)

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

bool	AcquireExternalFD (void)

void	ReserveExternalFD (void)

void	ReleaseExternalFD (void)

static void	ReportTemporaryFileUsage (const char *path, off_t size)

static void	RegisterTemporaryFile (File file)

File	PathNameOpenFile (const char *fileName, int fileFlags)

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

void	PathNameCreateTemporaryDir (const char basedir, const char directory)

void	PathNameDeleteTemporaryDir (const char *dirname)

File	OpenTemporaryFile (bool interXact)

void	TempTablespacePath (char *path, Oid tablespace)

File	PathNameCreateTemporaryFile (const char *path, bool error_on_failure)

File	PathNameOpenTemporaryFile (const char *path, int mode)

bool	PathNameDeleteTemporaryFile (const char *path, bool error_on_failure)

void	FileClose (File file)

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

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

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

int	FileWrite (File file, const void *buffer, size_t amount, off_t offset, uint32 wait_event_info)

int	FileSync (File file, uint32 wait_event_info)

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

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

off_t	FileSize (File file)

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

char *	FilePathName (File file)

int	FileGetRawDesc (File file)

int	FileGetRawFlags (File file)

mode_t	FileGetRawMode (File file)

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

int	OpenTransientFile (const char *fileName, int fileFlags)

int	OpenTransientFilePerm (const char *fileName, int fileFlags, mode_t 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)

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

int	FreeDir (DIR *dir)

int	ClosePipeStream (FILE *file)

void	closeAllVfds (void)

void	SetTempTablespaces (Oid *tableSpaces, int numSpaces)

bool	TempTablespacesAreSet (void)

int	GetTempTablespaces (Oid *tableSpaces, int numSpaces)

Oid	GetNextTempTableSpace (void)

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

void	AtEOXact_Files (bool isCommit)

void	RemovePgTempFiles (void)

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

bool	looks_like_temp_rel_name (const char *name)

void	SyncDataDirectory (void)

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

int	MakePGDirectory (const char *directoryName)

int	data_sync_elevel (int elevel)

bool	check_debug_io_direct (char newval, void extra, GucSource source)

void	assign_debug_io_direct (const char newval, void extra)

Variables
int	max_files_per_process = 1000

int	max_safe_fds = FD_MINFREE

bool	data_sync_retry = false

int	recovery_init_sync_method = DATA_DIR_SYNC_METHOD_FSYNC

int	io_direct_flags

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 int	numExternalFDs = 0

static long	tempFileCounter = 0

static Oid *	tempTableSpaces = NULL

static int	numTempTableSpaces = -1

static int	nextTempTableSpace = 0

Macro Definition Documentation

◆ DO_DB

#define DO_DB ( A ) ((void) 0)

Definition at line 180 of file fd.c.

◆ FD_CLOSE_AT_EOXACT

#define FD_CLOSE_AT_EOXACT (1 << 1) /* T = close at eoXact */

Definition at line 193 of file fd.c.

◆ FD_DELETE_AT_CLOSE

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

Definition at line 192 of file fd.c.

◆ FD_MINFREE

#define FD_MINFREE 48

Definition at line 138 of file fd.c.

◆ FD_TEMP_FILE_LIMIT

#define FD_TEMP_FILE_LIMIT (1 << 2) /* T = respect temp_file_limit */

Definition at line 194 of file fd.c.

◆ FileIsNotOpen

#define FileIsNotOpen ( file ) (VfdCache[file].fd == VFD_CLOSED)

Definition at line 189 of file fd.c.

◆ FileIsValid

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

Definition at line 186 of file fd.c.

◆ NUM_RESERVED_FDS

#define NUM_RESERVED_FDS 10

Definition at line 129 of file fd.c.

◆ VFD_CLOSED

#define VFD_CLOSED (-1)

Definition at line 184 of file fd.c.

Typedef Documentation

◆ Vfd

typedef struct vfd Vfd

Enumeration Type Documentation

◆ AllocateDescKind

enum AllocateDescKind

Enumerator
AllocateDescFile
AllocateDescPipe
AllocateDescDir
AllocateDescRawFD

Definition at line 247 of file fd.c.

 {
     AllocateDescFile,
     AllocateDescPipe,
     AllocateDescDir,
     AllocateDescRawFD
 } AllocateDescKind;

Function Documentation

◆ AcquireExternalFD()

bool AcquireExternalFD ( void )

Definition at line 1138 of file fd.c.

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

References max_safe_fds, numExternalFDs, and ReserveExternalFD().

Referenced by CreateWaitEventSet(), and libpqsrv_connect_prepare().

◆ AllocateDir()

DIR* AllocateDir ( const char * dirname )

Definition at line 2788 of file fd.c.

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

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

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

◆ AllocateFile()

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

Definition at line 2528 of file fd.c.

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

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

Referenced by AlterSystemSetConfigFile(), apw_dump_now(), apw_load_buffers(), BeginCopyFrom(), BeginCopyTo(), checkControlFile(), do_pg_backup_stop(), entry_reset(), existsTimeLineHistory(), ExportSnapshot(), gc_qtexts(), GetHugePageSize(), ImportSnapshot(), load_dh_file(), load_relcache_init_file(), open_auth_file(), parse_extension_control_file(), ParseTzFile(), pg_current_logfile(), pg_file_write_internal(), pg_promote(), pgss_shmem_shutdown(), pgss_shmem_startup(), pgstat_read_statsfile(), pgstat_write_statsfile(), read_backup_label(), read_binary_file(), read_tablespace_map(), read_whole_file(), readTimeLineHistory(), tsearch_readline_begin(), ValidatePgVersion(), write_relcache_init_file(), XLogArchiveForceDone(), and XLogArchiveNotify().

◆ AllocateVfd()

static File AllocateVfd ( void )

static

Definition at line 1366 of file fd.c.

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

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

Referenced by PathNameOpenFilePerm().

◆ assign_debug_io_direct()

void assign_debug_io_direct	(	const char *	newval,
		void *	extra
	)

Definition at line 3969 of file fd.c.

 {
     int        *flags = (int *) extra;
  
     io_direct_flags = *flags;
 }

References io_direct_flags.

◆ AtEOSubXact_Files()

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

Definition at line 3077 of file fd.c.

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

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

Referenced by AbortSubTransaction(), basic_archive_file(), and CommitSubTransaction().

◆ AtEOXact_Files()

void AtEOXact_Files ( bool isCommit )

Definition at line 3110 of file fd.c.

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

References CleanupTempFiles(), numTempTableSpaces, and tempTableSpaces.

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

◆ BasicOpenFile()

int BasicOpenFile	(	const char *	fileName,
		int	fileFlags
	)

Definition at line 1039 of file fd.c.

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

References BasicOpenFilePerm(), and pg_file_create_mode.

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

◆ BasicOpenFilePerm()

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

Definition at line 1061 of file fd.c.

 {
     int         fd;
  
 tryAgain:
 #ifdef PG_O_DIRECT_USE_F_NOCACHE
  
     /*
      * The value we defined to stand in for O_DIRECT when simulating it with
      * F_NOCACHE had better not collide with any of the standard flags.
      */
     StaticAssertStmt((PG_O_DIRECT &
                       (O_APPEND |
                        O_CLOEXEC |
                        O_CREAT |
                        O_DSYNC |
                        O_EXCL |
                        O_RDWR |
                        O_RDONLY |
                        O_SYNC |
                        O_TRUNC |
                        O_WRONLY)) == 0,
                      "PG_O_DIRECT value collides with standard flag");
     fd = open(fileName, fileFlags & ~PG_O_DIRECT, fileMode);
 #else
     fd = open(fileName, fileFlags, fileMode);
 #endif
  
     if (fd >= 0)
     {
 #ifdef PG_O_DIRECT_USE_F_NOCACHE
         if (fileFlags & PG_O_DIRECT)
         {
             if (fcntl(fd, F_NOCACHE, 1) < 0)
             {
                 int         save_errno = errno;
  
                 close(fd);
                 errno = save_errno;
                 return -1;
             }
         }
 #endif
  
         return fd;              /* success! */
     }
  
     if (errno == EMFILE || errno == ENFILE)
     {
         int         save_errno = errno;
  
         ereport(LOG,
                 (errcode(ERRCODE_INSUFFICIENT_RESOURCES),
                  errmsg("out of file descriptors: %m; release and retry")));
         errno = 0;
         if (ReleaseLruFile())
             goto tryAgain;
         errno = save_errno;
     }
  
     return -1;                  /* failure */
 }

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

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

◆ BeforeShmemExit_Files()

static void BeforeShmemExit_Files	(	int	code,
		Datum	arg
	)

static

Definition at line 3124 of file fd.c.

 {
     CleanupTempFiles(false, true);
  
     /* prevent further temp files from being created */
 #ifdef USE_ASSERT_CHECKING
     temporary_files_allowed = false;
 #endif
 }

References CleanupTempFiles().

Referenced by InitTemporaryFileAccess().

◆ check_debug_io_direct()

bool check_debug_io_direct	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 3887 of file fd.c.

 {
     bool        result = true;
     int         flags;
  
 #if PG_O_DIRECT == 0
     if (strcmp(*newval, "") != 0)
     {
         GUC_check_errdetail("debug_io_direct is not supported on this platform.");
         result = false;
     }
     flags = 0;
 #else
     List       *elemlist;
     ListCell   *l;
     char       *rawstring;
  
     /* Need a modifiable copy of string */
     rawstring = pstrdup(*newval);
  
     if (!SplitGUCList(rawstring, ',', &elemlist))
     {
         GUC_check_errdetail("invalid list syntax in parameter \"%s\"",
                             "debug_io_direct");
         pfree(rawstring);
         list_free(elemlist);
         return false;
     }
  
     flags = 0;
     foreach(l, elemlist)
     {
         char       *item = (char *) lfirst(l);
  
         if (pg_strcasecmp(item, "data") == 0)
             flags |= IO_DIRECT_DATA;
         else if (pg_strcasecmp(item, "wal") == 0)
             flags |= IO_DIRECT_WAL;
         else if (pg_strcasecmp(item, "wal_init") == 0)
             flags |= IO_DIRECT_WAL_INIT;
         else
         {
             GUC_check_errdetail("invalid option \"%s\"", item);
             result = false;
             break;
         }
     }
  
     /*
      * It's possible to configure block sizes smaller than our assumed I/O
      * alignment size, which could result in invalid I/O requests.
      */
 #if XLOG_BLCKSZ < PG_IO_ALIGN_SIZE
     if (result && (flags & (IO_DIRECT_WAL | IO_DIRECT_WAL_INIT)))
     {
         GUC_check_errdetail("debug_io_direct is not supported for WAL because XLOG_BLCKSZ is too small");
         result = false;
     }
 #endif
 #if BLCKSZ < PG_IO_ALIGN_SIZE
     if (result && (flags & IO_DIRECT_DATA))
     {
         GUC_check_errdetail("debug_io_direct is not supported for data because BLCKSZ is too small");
         result = false;
     }
 #endif
  
     pfree(rawstring);
     list_free(elemlist);
 #endif
  
     if (!result)
         return result;
  
     /* Save the flags in *extra, for use by assign_debug_io_direct */
     *extra = guc_malloc(ERROR, sizeof(int));
     *((int *) *extra) = flags;
  
     return result;
 }

References ERROR, GUC_check_errdetail, guc_malloc(), IO_DIRECT_DATA, IO_DIRECT_WAL, IO_DIRECT_WAL_INIT, lfirst, list_free(), newval, pfree(), pg_strcasecmp(), pstrdup(), and SplitGUCList().

◆ CleanupTempFiles()

static void CleanupTempFiles	(	bool	isCommit,
		bool	isProcExit
	)

static

Definition at line 3147 of file fd.c.

 {
     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_DELETE_AT_CLOSE) || (fdstate & FD_CLOSE_AT_EOXACT)) &&
                 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_CLOSE_AT_EOXACT)
                 {
                     elog(WARNING,
                          "temporary file %s not closed at end-of-transaction",
                          VfdCache[i].fileName);
                     FileClose(i);
                 }
             }
         }
  
         have_xact_temporary_files = false;
     }
  
     /* Complain if any allocated files remain open at commit. */
     if (isCommit && numAllocatedDescs > 0)
         elog(WARNING, "%d temporary files and directories not closed at end-of-transaction",
              numAllocatedDescs);
  
     /* Clean up "allocated" stdio files, dirs and fds. */
     while (numAllocatedDescs > 0)
         FreeDesc(&allocatedDescs[0]);
 }

References allocatedDescs, Assert(), elog(), FD_CLOSE_AT_EOXACT, FD_DELETE_AT_CLOSE, vfd::fdstate, FileClose(), FileIsNotOpen, FreeDesc(), have_xact_temporary_files, i, numAllocatedDescs, SizeVfdCache, VfdCache, and WARNING.

Referenced by AtEOXact_Files(), and BeforeShmemExit_Files().

◆ closeAllVfds()

void closeAllVfds ( void )

Definition at line 2965 of file fd.c.

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

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

Referenced by standard_ProcessUtility().

◆ ClosePipeStream()

int ClosePipeStream ( FILE * file )

Definition at line 2936 of file fd.c.

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

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

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

◆ CloseTransientFile()

int CloseTransientFile ( int fd )

Definition at line 2754 of file fd.c.

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

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

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

◆ count_usable_fds()

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

static

Definition at line 916 of file fd.c.

 {
     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
     getrlimit_status = getrlimit(RLIMIT_NOFILE, &rlim);
     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(2);
         if (thisfd < 0)
         {
             /* Expect EMFILE or ENFILE, else it's fishy */
             if (errno != EMFILE && errno != ENFILE)
                 elog(WARNING, "duplicating stderr file descriptor 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;
 }

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

Referenced by set_max_safe_fds().

◆ data_sync_elevel()

int data_sync_elevel ( int elevel )

Definition at line 3881 of file fd.c.

 {
     return data_sync_retry ? elevel : PANIC;
 }

References data_sync_retry, and PANIC.

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

◆ datadir_fsync_fname()

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

static

Definition at line 3704 of file fd.c.

 {
     ereport_startup_progress("syncing data directory (fsync), elapsed time: %ld.%02d s, current path: %s",
                              fname);
  
     /*
      * We want to silently ignoring errors about unreadable files.  Pass that
      * desire on to fsync_fname_ext().
      */
     fsync_fname_ext(fname, isdir, true, elevel);
 }

References ereport_startup_progress, and fsync_fname_ext().

Referenced by SyncDataDirectory().

◆ Delete()

static void Delete ( File file )

static

Definition at line 1220 of file fd.c.

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

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

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

◆ durable_rename()

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

Definition at line 734 of file fd.c.

 {
     int         fd;
  
     /*
      * First fsync the old and target path (if it exists), to ensure that they
      * are properly persistent on disk. Syncing the target file is not
      * strictly necessary, but it makes it easier to reason about crashes;
      * because it's then guaranteed that either source or target file exists
      * after a crash.
      */
     if (fsync_fname_ext(oldfile, false, false, elevel) != 0)
         return -1;
  
     fd = OpenTransientFile(newfile, PG_BINARY | O_RDWR);
     if (fd < 0)
     {
         if (errno != ENOENT)
         {
             ereport(elevel,
                     (errcode_for_file_access(),
                      errmsg("could not open file \"%s\": %m", newfile)));
             return -1;
         }
     }
     else
     {
         if (pg_fsync(fd) != 0)
         {
             int         save_errno;
  
             /* close file upon error, might not be in transaction context */
             save_errno = errno;
             CloseTransientFile(fd);
             errno = save_errno;
  
             ereport(elevel,
                     (errcode_for_file_access(),
                      errmsg("could not fsync file \"%s\": %m", newfile)));
             return -1;
         }
  
         if (CloseTransientFile(fd) != 0)
         {
             ereport(elevel,
                     (errcode_for_file_access(),
                      errmsg("could not close file \"%s\": %m", newfile)));
             return -1;
         }
     }
  
     /* Time to do the real deal... */
     if (rename(oldfile, newfile) < 0)
     {
         ereport(elevel,
                 (errcode_for_file_access(),
                  errmsg("could not rename file \"%s\" to \"%s\": %m",
                         oldfile, newfile)));
         return -1;
     }
  
     /*
      * To guarantee renaming the file is persistent, fsync the file with its
      * new name, and its containing directory.
      */
     if (fsync_fname_ext(newfile, false, false, elevel) != 0)
         return -1;
  
     if (fsync_parent_path(newfile, elevel) != 0)
         return -1;
  
     return 0;
 }

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

Referenced by AlterSystemSetConfigFile(), apw_dump_now(), BaseBackup(), basic_archive_file_internal(), bbsink_server_end_manifest(), CheckPointReplicationOrigin(), CleanupAfterArchiveRecovery(), dir_close(), InitWalRecovery(), InstallXLogFileSegment(), KeepFileRestoredFromArchive(), pgss_shmem_shutdown(), StartupXLOG(), write_relmap_file(), writeTimeLineHistory(), writeTimeLineHistoryFile(), and XLogArchiveForceDone().

◆ durable_unlink()

int durable_unlink	(	const char *	fname,
		int	elevel
	)

Definition at line 824 of file fd.c.

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

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

Referenced by InstallXLogFileSegment(), RemoveXlogFile(), and StartupXLOG().

◆ FileAccess()

static int FileAccess ( File file )

static

Definition at line 1444 of file fd.c.

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

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

Referenced by FileFallocate(), FilePrefetch(), FileRead(), FileSize(), FileSync(), FileTruncate(), FileWrite(), FileWriteback(), and FileZero().

◆ FileClose()

void FileClose ( File file )

Definition at line 1930 of file fd.c.

 {
     Vfd        *vfdP;
  
     Assert(FileIsValid(file));
  
     DO_DB(elog(LOG, "FileClose: %d (%s)",
                file, VfdCache[file].fileName));
  
     vfdP = &VfdCache[file];
  
     if (!FileIsNotOpen(file))
     {
         /* close the file */
         if (close(vfdP->fd) != 0)
         {
             /*
              * We may need to panic on failure to close non-temporary files;
              * see LruDelete.
              */
             elog(vfdP->fdstate & FD_TEMP_FILE_LIMIT ? LOG : data_sync_elevel(LOG),
                  "could not close file \"%s\": %m", vfdP->fileName);
         }
  
         --nfile;
         vfdP->fd = VFD_CLOSED;
  
         /* remove the file from the lru ring */
         Delete(file);
     }
  
     if (vfdP->fdstate & FD_TEMP_FILE_LIMIT)
     {
         /* Subtract its size from current usage (do first in case of error) */
         temporary_files_size -= vfdP->fileSize;
         vfdP->fileSize = 0;
     }
  
     /*
      * Delete the file if it was temporary, and make a log entry if wanted
      */
     if (vfdP->fdstate & FD_DELETE_AT_CLOSE)
     {
         struct stat filestats;
         int         stat_errno;
  
         /*
          * If we get an error, as could happen within the ereport/elog calls,
          * we'll come right back here during transaction abort.  Reset the
          * flag to ensure that we can't get into an infinite loop.  This code
          * is arranged to ensure that the worst-case consequence is failing to
          * emit log message(s), not failing to attempt the unlink.
          */
         vfdP->fdstate &= ~FD_DELETE_AT_CLOSE;
  
  
         /* first try the stat() */
         if (stat(vfdP->fileName, &filestats))
             stat_errno = errno;
         else
             stat_errno = 0;
  
         /* in any case do the unlink */
         if (unlink(vfdP->fileName))
             ereport(LOG,
                     (errcode_for_file_access(),
                      errmsg("could not delete file \"%s\": %m", vfdP->fileName)));
  
         /* and last report the stat results */
         if (stat_errno == 0)
             ReportTemporaryFileUsage(vfdP->fileName, filestats.st_size);
         else
         {
             errno = stat_errno;
             ereport(LOG,
                     (errcode_for_file_access(),
                      errmsg("could not stat file \"%s\": %m", vfdP->fileName)));
         }
     }
  
     /* Unregister it from the resource owner */
     if (vfdP->resowner)
         ResourceOwnerForgetFile(vfdP->resowner, file);
  
     /*
      * Return the Vfd slot to the free list
      */
     FreeVfd(file);
 }

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

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

◆ FileFallocate()

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

Definition at line 2314 of file fd.c.

 {
 #ifdef HAVE_POSIX_FALLOCATE
     int         returnCode;
  
     Assert(FileIsValid(file));
  
     DO_DB(elog(LOG, "FileFallocate: %d (%s) " INT64_FORMAT " " INT64_FORMAT,
                file, VfdCache[file].fileName,
                (int64) offset, (int64) amount));
  
     returnCode = FileAccess(file);
     if (returnCode < 0)
         return -1;
  
 retry:
     pgstat_report_wait_start(wait_event_info);
     returnCode = posix_fallocate(VfdCache[file].fd, offset, amount);
     pgstat_report_wait_end();
  
     if (returnCode == 0)
         return 0;
     else if (returnCode == EINTR)
         goto retry;
  
     /* for compatibility with %m printing etc */
     errno = returnCode;
  
     /*
      * Return in cases of a "real" failure, if fallocate is not supported,
      * fall through to the FileZero() backed implementation.
      */
     if (returnCode != EINVAL && returnCode != EOPNOTSUPP)
         return -1;
 #endif
  
     return FileZero(file, offset, amount, wait_event_info);
 }

References Assert(), DO_DB, EINTR, elog(), EOPNOTSUPP, fd(), FileAccess(), FileIsValid, FileZero(), INT64_FORMAT, LOG, pgstat_report_wait_end(), pgstat_report_wait_start(), and VfdCache.

Referenced by mdzeroextend().

◆ FileGetRawDesc()

int FileGetRawDesc ( File file )

Definition at line 2422 of file fd.c.

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

References Assert(), vfd::fd, FileIsValid, and VfdCache.

◆ FileGetRawFlags()

int FileGetRawFlags ( File file )

Definition at line 2432 of file fd.c.

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

References Assert(), vfd::fileFlags, FileIsValid, and VfdCache.

◆ FileGetRawMode()

mode_t FileGetRawMode ( File file )

Definition at line 2442 of file fd.c.

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

References Assert(), FileIsValid, vfd::fileMode, and VfdCache.

◆ FilePathName()

char* FilePathName ( File file )

Definition at line 2406 of file fd.c.

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

References Assert(), FileIsValid, vfd::fileName, and VfdCache.

Referenced by _mdnblocks(), bbsink_server_archive_contents(), bbsink_server_end_archive(), bbsink_server_manifest_contents(), BufFileDumpBuffer(), BufFileLoadBuffer(), BufFileSeek(), BufFileSize(), BufFileTruncateFileSet(), mdextend(), mdimmedsync(), mdread(), mdsyncfiletag(), mdtruncate(), mdwrite(), mdzeroextend(), and register_dirty_segment().

◆ FilePrefetch()

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

Definition at line 2030 of file fd.c.

 {
 #if defined(USE_POSIX_FADVISE) && defined(POSIX_FADV_WILLNEED)
     int         returnCode;
  
     Assert(FileIsValid(file));
  
     DO_DB(elog(LOG, "FilePrefetch: %d (%s) " INT64_FORMAT " " INT64_FORMAT,
                file, VfdCache[file].fileName,
                (int64) offset, (int64) amount));
  
     returnCode = FileAccess(file);
     if (returnCode < 0)
         return returnCode;
  
 retry:
     pgstat_report_wait_start(wait_event_info);
     returnCode = posix_fadvise(VfdCache[file].fd, offset, amount,
                                POSIX_FADV_WILLNEED);
     pgstat_report_wait_end();
  
     if (returnCode == EINTR)
         goto retry;
  
     return returnCode;
 #else
     Assert(FileIsValid(file));
     return 0;
 #endif
 }

References Assert(), DO_DB, EINTR, elog(), fd(), FileAccess(), FileIsValid, INT64_FORMAT, LOG, pgstat_report_wait_end(), pgstat_report_wait_start(), and VfdCache.

Referenced by mdprefetch().

◆ FileRead()

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

Definition at line 2088 of file fd.c.

 {
     int         returnCode;
     Vfd        *vfdP;
  
     Assert(FileIsValid(file));
  
     DO_DB(elog(LOG, "FileRead: %d (%s) " INT64_FORMAT " %zu %p",
                file, VfdCache[file].fileName,
                (int64) offset,
                amount, buffer));
  
     returnCode = FileAccess(file);
     if (returnCode < 0)
         return returnCode;
  
     vfdP = &VfdCache[file];
  
 retry:
     pgstat_report_wait_start(wait_event_info);
     returnCode = pg_pread(vfdP->fd, buffer, amount, offset);
     pgstat_report_wait_end();
  
     if (returnCode < 0)
     {
         /*
          * Windows may run out of kernel buffers and return "Insufficient
          * system resources" error.  Wait a bit and retry to solve it.
          *
          * It is rumored that EINTR is also possible on some Unix filesystems,
          * in which case immediate retry is indicated.
          */
 #ifdef WIN32
         DWORD       error = GetLastError();
  
         switch (error)
         {
             case ERROR_NO_SYSTEM_RESOURCES:
                 pg_usleep(1000L);
                 errno = EINTR;
                 break;
             default:
                 _dosmaperr(error);
                 break;
         }
 #endif
         /* OK to retry if interrupted */
         if (errno == EINTR)
             goto retry;
     }
  
     return returnCode;
 }

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

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

◆ FileSize()

off_t FileSize ( File file )

Definition at line 2354 of file fd.c.

 {
     Assert(FileIsValid(file));
  
     DO_DB(elog(LOG, "FileSize %d (%s)",
                file, VfdCache[file].fileName));
  
     if (FileIsNotOpen(file))
     {
         if (FileAccess(file) < 0)
             return (off_t) -1;
     }
  
     return lseek(VfdCache[file].fd, 0, SEEK_END);
 }

References Assert(), DO_DB, elog(), fd(), FileAccess(), FileIsNotOpen, FileIsValid, LOG, and VfdCache.

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

◆ FileSync()

int FileSync	(	File	file,
		uint32	wait_event_info
	)

Definition at line 2242 of file fd.c.

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

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

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

◆ FileTruncate()

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

Definition at line 2371 of file fd.c.

 {
     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 = pg_ftruncate(VfdCache[file].fd, offset);
     pgstat_report_wait_end();
  
     if (returnCode == 0 && VfdCache[file].fileSize > offset)
     {
         /* adjust our state for truncation of a temp file */
         Assert(VfdCache[file].fdstate & FD_TEMP_FILE_LIMIT);
         temporary_files_size -= VfdCache[file].fileSize - offset;
         VfdCache[file].fileSize = offset;
     }
  
     return returnCode;
 }

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

Referenced by BufFileTruncateFileSet(), and mdtruncate().

◆ FileWrite()

int FileWrite	(	File	file,
		const void *	buffer,
		size_t	amount,
		off_t	offset,
		uint32	wait_event_info
	)

Definition at line 2144 of file fd.c.

 {
     int         returnCode;
     Vfd        *vfdP;
  
     Assert(FileIsValid(file));
  
     DO_DB(elog(LOG, "FileWrite: %d (%s) " INT64_FORMAT " %zu %p",
                file, VfdCache[file].fileName,
                (int64) offset,
                amount, buffer));
  
     returnCode = FileAccess(file);
     if (returnCode < 0)
         return returnCode;
  
     vfdP = &VfdCache[file];
  
     /*
      * If enforcing temp_file_limit and it's a temp file, check to see if the
      * write would overrun temp_file_limit, and throw error if so.  Note: it's
      * really a modularity violation to throw error here; we should set errno
      * and return -1.  However, there's no way to report a suitable error
      * message if we do that.  All current callers would just throw error
      * immediately anyway, so this is safe at present.
      */
     if (temp_file_limit >= 0 && (vfdP->fdstate & FD_TEMP_FILE_LIMIT))
     {
         off_t       past_write = offset + amount;
  
         if (past_write > vfdP->fileSize)
         {
             uint64      newTotal = temporary_files_size;
  
             newTotal += past_write - vfdP->fileSize;
             if (newTotal > (uint64) temp_file_limit * (uint64) 1024)
                 ereport(ERROR,
                         (errcode(ERRCODE_CONFIGURATION_LIMIT_EXCEEDED),
                          errmsg("temporary file size exceeds temp_file_limit (%dkB)",
                                 temp_file_limit)));
         }
     }
  
 retry:
     errno = 0;
     pgstat_report_wait_start(wait_event_info);
     returnCode = pg_pwrite(VfdCache[file].fd, buffer, amount, offset);
     pgstat_report_wait_end();
  
     /* if write didn't set errno, assume problem is no disk space */
     if (returnCode != amount && errno == 0)
         errno = ENOSPC;
  
     if (returnCode >= 0)
     {
         /*
          * Maintain fileSize and temporary_files_size if it's a temp file.
          */
         if (vfdP->fdstate & FD_TEMP_FILE_LIMIT)
         {
             off_t       past_write = offset + amount;
  
             if (past_write > vfdP->fileSize)
             {
                 temporary_files_size += past_write - vfdP->fileSize;
                 vfdP->fileSize = past_write;
             }
         }
     }
     else
     {
         /*
          * See comments in FileRead()
          */
 #ifdef WIN32
         DWORD       error = GetLastError();
  
         switch (error)
         {
             case ERROR_NO_SYSTEM_RESOURCES:
                 pg_usleep(1000L);
                 errno = EINTR;
                 break;
             default:
                 _dosmaperr(error);
                 break;
         }
 #endif
         /* OK to retry if interrupted */
         if (errno == EINTR)
             goto retry;
     }
  
     return returnCode;
 }

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

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

◆ FileWriteback()

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

Definition at line 2062 of file fd.c.

 {
     int         returnCode;
  
     Assert(FileIsValid(file));
  
     DO_DB(elog(LOG, "FileWriteback: %d (%s) " INT64_FORMAT " " INT64_FORMAT,
                file, VfdCache[file].fileName,
                (int64) offset, (int64) nbytes));
  
     if (nbytes <= 0)
         return;
  
     if (VfdCache[file].fileFlags & PG_O_DIRECT)
         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();
 }

References Assert(), DO_DB, elog(), fd(), FileAccess(), FileIsValid, INT64_FORMAT, LOG, pg_flush_data(), PG_O_DIRECT, pgstat_report_wait_end(), pgstat_report_wait_start(), and VfdCache.

Referenced by mdwriteback().

◆ FileZero()

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

Definition at line 2269 of file fd.c.

 {
     int         returnCode;
     ssize_t     written;
  
     Assert(FileIsValid(file));
  
     DO_DB(elog(LOG, "FileZero: %d (%s) " INT64_FORMAT " " INT64_FORMAT,
                file, VfdCache[file].fileName,
                (int64) offset, (int64) amount));
  
     returnCode = FileAccess(file);
     if (returnCode < 0)
         return returnCode;
  
     pgstat_report_wait_start(wait_event_info);
     written = pg_pwrite_zeros(VfdCache[file].fd, amount, offset);
     pgstat_report_wait_end();
  
     if (written < 0)
         return -1;
     else if (written != amount)
     {
         /* if errno is unset, assume problem is no disk space */
         if (errno == 0)
             errno = ENOSPC;
         return -1;
     }
  
     return 0;
 }

References Assert(), DO_DB, elog(), fd(), FileAccess(), FileIsValid, INT64_FORMAT, LOG, pg_pwrite_zeros(), pgstat_report_wait_end(), pgstat_report_wait_start(), and VfdCache.

Referenced by FileFallocate(), and mdzeroextend().

◆ FreeDesc()

static int FreeDesc ( AllocateDesc * desc )

static

Definition at line 2687 of file fd.c.

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

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

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

◆ FreeDir()

int FreeDir ( DIR * dir )

Definition at line 2906 of file fd.c.

 {
     int         i;
  
     /* Nothing to do if AllocateDir failed */
     if (dir == NULL)
         return 0;
  
     DO_DB(elog(LOG, "FreeDir: Allocated %d", numAllocatedDescs));
  
     /* Remove dir from list of allocated dirs, if it's present */
     for (i = numAllocatedDescs; --i >= 0;)
     {
         AllocateDesc *desc = &allocatedDescs[i];
  
         if (desc->kind == AllocateDescDir && desc->desc.dir == dir)
             return FreeDesc(desc);
     }
  
     /* Only get here if someone passes us a dir not in allocatedDescs */
     elog(WARNING, "dir passed to FreeDir was not obtained from AllocateDir");
  
     return closedir(dir);
 }

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

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

◆ FreeFile()

int FreeFile ( FILE * file )

Definition at line 2726 of file fd.c.

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

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

Referenced by AlterSystemSetConfigFile(), apw_dump_now(), apw_load_buffers(), checkControlFile(), do_pg_backup_stop(), EndCopy(), EndCopyFrom(), entry_reset(), existsTimeLineHistory(), ExportSnapshot(), free_auth_file(), gc_qtexts(), GetHugePageSize(), ImportSnapshot(), load_dh_file(), load_relcache_init_file(), parse_extension_control_file(), ParseTzFile(), pg_current_logfile(), pg_file_write_internal(), pg_promote(), pgss_shmem_shutdown(), pgss_shmem_startup(), pgstat_read_statsfile(), pgstat_write_statsfile(), read_backup_label(), read_binary_file(), read_tablespace_map(), read_whole_file(), readTimeLineHistory(), tsearch_readline_end(), ValidatePgVersion(), write_relcache_init_file(), XLogArchiveForceDone(), and XLogArchiveNotify().

◆ FreeVfd()

static void FreeVfd ( File file )

static

Definition at line 1424 of file fd.c.

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

References DO_DB, elog(), vfd::fdstate, vfd::fileName, free, LOG, vfd::nextFree, and VfdCache.

Referenced by FileClose(), and PathNameOpenFilePerm().

◆ fsync_fname()

void fsync_fname	(	const char *	fname,
		bool	isdir
	)

Definition at line 708 of file fd.c.

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

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

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

◆ fsync_fname_ext()

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

Definition at line 3742 of file fd.c.

 {
     int         fd;
     int         flags;
     int         returncode;
  
     /*
      * Some OSs require directories to be opened read-only whereas other
      * systems don't allow us to fsync files opened read-only; so we need both
      * cases here.  Using O_RDWR will cause us to fail to fsync files that are
      * not writable by our userid, but we assume that's OK.
      */
     flags = PG_BINARY;
     if (!isdir)
         flags |= O_RDWR;
     else
         flags |= O_RDONLY;
  
     fd = OpenTransientFile(fname, flags);
  
     /*
      * Some OSs don't allow us to open directories at all (Windows returns
      * EACCES), just ignore the error in that case.  If desired also silently
      * ignoring errors about unreadable files. Log others.
      */
     if (fd < 0 && isdir && (errno == EISDIR || errno == EACCES))
         return 0;
     else if (fd < 0 && ignore_perm && errno == EACCES)
         return 0;
     else if (fd < 0)
     {
         ereport(elevel,
                 (errcode_for_file_access(),
                  errmsg("could not open file \"%s\": %m", fname)));
         return -1;
     }
  
     returncode = pg_fsync(fd);
  
     /*
      * Some OSes don't allow us to fsync directories at all, so we can ignore
      * those errors. Anything else needs to be logged.
      */
     if (returncode != 0 && !(isdir && (errno == EBADF || errno == EINVAL)))
     {
         int         save_errno;
  
         /* close file upon error, might not be in transaction context */
         save_errno = errno;
         (void) CloseTransientFile(fd);
         errno = save_errno;
  
         ereport(elevel,
                 (errcode_for_file_access(),
                  errmsg("could not fsync file \"%s\": %m", fname)));
         return -1;
     }
  
     if (CloseTransientFile(fd) != 0)
     {
         ereport(elevel,
                 (errcode_for_file_access(),
                  errmsg("could not close file \"%s\": %m", fname)));
         return -1;
     }
  
     return 0;
 }

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

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

◆ fsync_parent_path()

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

static

Definition at line 3818 of file fd.c.

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

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

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

◆ GetNextTempTableSpace()

Oid GetNextTempTableSpace ( void )

Definition at line 3056 of file fd.c.

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

References InvalidOid, nextTempTableSpace, numTempTableSpaces, and tempTableSpaces.

Referenced by GetDefaultTablespace(), and OpenTemporaryFile().

◆ GetTempTablespaces()

int GetTempTablespaces	(	Oid *	tableSpaces,
		int	numSpaces
	)

Definition at line 3038 of file fd.c.

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

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

Referenced by FileSetInit().

◆ InitFileAccess()

void InitFileAccess ( void )

Definition at line 855 of file fd.c.

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

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

Referenced by BaseInit().

◆ InitTemporaryFileAccess()

void InitTemporaryFileAccess ( void )

Definition at line 885 of file fd.c.

 {
     Assert(SizeVfdCache != 0);  /* InitFileAccess() needs to have run */
     Assert(!temporary_files_allowed);   /* call me only once */
  
     /*
      * Register before-shmem-exit hook to ensure temp files are dropped while
      * we can still report stats.
      */
     before_shmem_exit(BeforeShmemExit_Files, 0);
  
 #ifdef USE_ASSERT_CHECKING
     temporary_files_allowed = true;
 #endif
 }

References Assert(), before_shmem_exit(), BeforeShmemExit_Files(), and SizeVfdCache.

Referenced by BaseInit().

◆ Insert()

static void Insert ( File file )

static

Definition at line 1265 of file fd.c.

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

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

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

◆ looks_like_temp_rel_name()

bool looks_like_temp_rel_name ( const char * name )

Definition at line 3394 of file fd.c.

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

References forkname_chars(), and name.

Referenced by RemovePgTempRelationFilesInDbspace(), and sendDir().

◆ LruDelete()

static void LruDelete ( File file )

static

Definition at line 1239 of file fd.c.

 {
     Vfd        *vfdP;
  
     Assert(file != 0);
  
     DO_DB(elog(LOG, "LruDelete %d (%s)",
                file, VfdCache[file].fileName));
  
     vfdP = &VfdCache[file];
  
     /*
      * 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) != 0)
         elog(vfdP->fdstate & FD_TEMP_FILE_LIMIT ? LOG : data_sync_elevel(LOG),
              "could not close file \"%s\": %m", vfdP->fileName);
     vfdP->fd = VFD_CLOSED;
     --nfile;
  
     /* delete the vfd record from the LRU ring */
     Delete(file);
 }

References Assert(), close, data_sync_elevel(), Delete(), DO_DB, elog(), vfd::fd, FD_TEMP_FILE_LIMIT, vfd::fdstate, vfd::fileName, LOG, nfile, VFD_CLOSED, and VfdCache.

Referenced by closeAllVfds(), and ReleaseLruFile().

◆ LruInsert()

static int LruInsert ( File file )

static

Definition at line 1287 of file fd.c.

 {
     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 = BasicOpenFilePerm(vfdP->fileName, vfdP->fileFlags,
                                      vfdP->fileMode);
         if (vfdP->fd < 0)
         {
             DO_DB(elog(LOG, "re-open failed: %m"));
             return -1;
         }
         else
         {
             ++nfile;
         }
     }
  
     /*
      * put it at the head of the Lru ring
      */
  
     Insert(file);
  
     return 0;
 }

References Assert(), BasicOpenFilePerm(), DO_DB, elog(), vfd::fd, vfd::fileFlags, FileIsNotOpen, vfd::fileMode, vfd::fileName, Insert(), LOG, nfile, ReleaseLruFiles(), and VfdCache.

Referenced by FileAccess().

◆ MakePGDirectory()

int MakePGDirectory ( const char * directoryName )

Definition at line 3858 of file fd.c.

 {
     return mkdir(directoryName, pg_dir_create_mode);
 }

References mkdir, and pg_dir_create_mode.

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

◆ OpenPipeStream()

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

Definition at line 2631 of file fd.c.

 {
     FILE       *file;
     int         save_errno;
  
     DO_DB(elog(LOG, "OpenPipeStream: Allocated %d (%s)",
                numAllocatedDescs, command));
  
     /* Can we allocate another non-virtual FD? */
     if (!reserveAllocatedDesc())
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_RESOURCES),
                  errmsg("exceeded maxAllocatedDescs (%d) while trying to execute command \"%s\"",
                         maxAllocatedDescs, command)));
  
     /* Close excess kernel FDs. */
     ReleaseLruFiles();
  
 TryAgain:
     fflush(NULL);
     pqsignal(SIGPIPE, SIG_DFL);
     errno = 0;
     file = popen(command, mode);
     save_errno = errno;
     pqsignal(SIGPIPE, SIG_IGN);
     errno = save_errno;
     if (file != NULL)
     {
         AllocateDesc *desc = &allocatedDescs[numAllocatedDescs];
  
         desc->kind = AllocateDescPipe;
         desc->desc.file = file;
         desc->create_subid = GetCurrentSubTransactionId();
         numAllocatedDescs++;
         return desc->desc.file;
     }
  
     if (errno == EMFILE || errno == ENFILE)
     {
         ereport(LOG,
                 (errcode(ERRCODE_INSUFFICIENT_RESOURCES),
                  errmsg("out of file descriptors: %m; release and retry")));
         if (ReleaseLruFile())
             goto TryAgain;
         errno = save_errno;
     }
  
     return NULL;
 }

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

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

◆ OpenTemporaryFile()

File OpenTemporaryFile ( bool interXact )

Definition at line 1676 of file fd.c.

 {
     File        file = 0;
  
     Assert(temporary_files_allowed);    /* check temp file access is up */
  
     /*
      * Make sure the current resource owner has space for this File before we
      * open it, if we'll be registering it below.
      */
     if (!interXact)
         ResourceOwnerEnlargeFiles(CurrentResourceOwner);
  
     /*
      * If some temp tablespace(s) have been given to us, try to use the next
      * one.  If a given tablespace can't be found, we silently fall back to
      * the database's default tablespace.
      *
      * BUT: if the temp file is slated to outlive the current transaction,
      * force it into the database's default tablespace, so that it will not
      * pose a threat to possible tablespace drop attempts.
      */
     if (numTempTableSpaces > 0 && !interXact)
     {
         Oid         tblspcOid = GetNextTempTableSpace();
  
         if (OidIsValid(tblspcOid))
             file = OpenTemporaryFileInTablespace(tblspcOid, false);
     }
  
     /*
      * If not, or if tablespace is bad, create in database's default
      * tablespace.  MyDatabaseTableSpace should normally be set before we get
      * here, but just in case it isn't, fall back to pg_default tablespace.
      */
     if (file <= 0)
         file = OpenTemporaryFileInTablespace(MyDatabaseTableSpace ?
                                              MyDatabaseTableSpace :
                                              DEFAULTTABLESPACE_OID,
                                              true);
  
     /* Mark it for deletion at close and temporary file size limit */
     VfdCache[file].fdstate |= FD_DELETE_AT_CLOSE | FD_TEMP_FILE_LIMIT;
  
     /* Register it with the current resource owner */
     if (!interXact)
         RegisterTemporaryFile(file);
  
     return file;
 }

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

Referenced by BufFileCreateTemp(), and extendBufFile().

◆ OpenTemporaryFileInTablespace()

static File OpenTemporaryFileInTablespace	(	Oid	tblspcOid,
		bool	rejectError
	)

static

Definition at line 1756 of file fd.c.

 {
     char        tempdirpath[MAXPGPATH];
     char        tempfilepath[MAXPGPATH];
     File        file;
  
     TempTablespacePath(tempdirpath, tblspcOid);
  
     /*
      * 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);
     if (file <= 0)
     {
         /*
          * We might need to create the tablespace's tempfile directory, if no
          * one has yet done so.
          *
          * Don't check for an error from MakePGDirectory; 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.
          */
         (void) MakePGDirectory(tempdirpath);
  
         file = PathNameOpenFile(tempfilepath,
                                 O_RDWR | O_CREAT | O_TRUNC | PG_BINARY);
         if (file <= 0 && rejectError)
             elog(ERROR, "could not create temporary file \"%s\": %m",
                  tempfilepath);
     }
  
     return file;
 }

References elog(), ERROR, MakePGDirectory(), MAXPGPATH, MyProcPid, PathNameOpenFile(), PG_BINARY, PG_TEMP_FILE_PREFIX, snprintf, tempFileCounter, and TempTablespacePath().

Referenced by OpenTemporaryFile().

◆ OpenTransientFile()

int OpenTransientFile	(	const char *	fileName,
		int	fileFlags
	)

Definition at line 2578 of file fd.c.

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

References OpenTransientFilePerm(), and pg_file_create_mode.

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

◆ OpenTransientFilePerm()

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

Definition at line 2587 of file fd.c.

 {
     int         fd;
  
     DO_DB(elog(LOG, "OpenTransientFile: Allocated %d (%s)",
                numAllocatedDescs, fileName));
  
     /* Can we allocate another non-virtual FD? */
     if (!reserveAllocatedDesc())
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_RESOURCES),
                  errmsg("exceeded maxAllocatedDescs (%d) while trying to open file \"%s\"",
                         maxAllocatedDescs, fileName)));
  
     /* Close excess kernel FDs. */
     ReleaseLruFiles();
  
     fd = BasicOpenFilePerm(fileName, fileFlags, fileMode);
  
     if (fd >= 0)
     {
         AllocateDesc *desc = &allocatedDescs[numAllocatedDescs];
  
         desc->kind = AllocateDescRawFD;
         desc->desc.fd = fd;
         desc->create_subid = GetCurrentSubTransactionId();
         numAllocatedDescs++;
  
         return fd;
     }
  
     return -1;                  /* failure */
 }

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

Referenced by be_lo_export(), and OpenTransientFile().

◆ PathNameCreateTemporaryDir()

void PathNameCreateTemporaryDir	(	const char *	basedir,
		const char *	directory
	)

Definition at line 1612 of file fd.c.

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

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

Referenced by FileSetCreate().

◆ PathNameCreateTemporaryFile()

File PathNameCreateTemporaryFile	(	const char *	path,
		bool	error_on_failure
	)

Definition at line 1813 of file fd.c.

 {
     File        file;
  
     Assert(temporary_files_allowed);    /* check temp file access is up */
  
     ResourceOwnerEnlargeFiles(CurrentResourceOwner);
  
     /*
      * Open the file.  Note: we don't use O_EXCL, in case there is an orphaned
      * temp file that can be reused.
      */
     file = PathNameOpenFile(path, O_RDWR | O_CREAT | O_TRUNC | PG_BINARY);
     if (file <= 0)
     {
         if (error_on_failure)
             ereport(ERROR,
                     (errcode_for_file_access(),
                      errmsg("could not create temporary file \"%s\": %m",
                             path)));
         else
             return file;
     }
  
     /* Mark it for temp_file_limit accounting. */
     VfdCache[file].fdstate |= FD_TEMP_FILE_LIMIT;
  
     /* Register it for automatic close. */
     RegisterTemporaryFile(file);
  
     return file;
 }

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

Referenced by FileSetCreate().

◆ PathNameDeleteTemporaryDir()

void PathNameDeleteTemporaryDir ( const char * dirname )

Definition at line 1643 of file fd.c.

 {
     struct stat statbuf;
  
     /* Silently ignore missing directory. */
     if (stat(dirname, &statbuf) != 0 && errno == ENOENT)
         return;
  
     /*
      * Currently, walkdir doesn't offer a way for our passed in function to
      * maintain state.  Perhaps it should, so that we could tell the caller
      * whether this operation succeeded or failed.  Since this operation is
      * used in a cleanup path, we wouldn't actually behave differently: we'll
      * just log failures.
      */
     walkdir(dirname, unlink_if_exists_fname, false, LOG);
 }

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

Referenced by FileSetDeleteAll().

◆ PathNameDeleteTemporaryFile()

bool PathNameDeleteTemporaryFile	(	const char *	path,
		bool	error_on_failure
	)

Definition at line 1884 of file fd.c.

 {
     struct stat filestats;
     int         stat_errno;
  
     /* Get the final size for pgstat reporting. */
     if (stat(path, &filestats) != 0)
         stat_errno = errno;
     else
         stat_errno = 0;
  
     /*
      * Unlike FileClose's automatic file deletion code, we tolerate
      * non-existence to support BufFileDeleteFileSet which doesn't know how
      * many segments it has to delete until it runs out.
      */
     if (stat_errno == ENOENT)
         return false;
  
     if (unlink(path) < 0)
     {
         if (errno != ENOENT)
             ereport(error_on_failure ? ERROR : LOG,
                     (errcode_for_file_access(),
                      errmsg("could not unlink temporary file \"%s\": %m",
                             path)));
         return false;
     }
  
     if (stat_errno == 0)
         ReportTemporaryFileUsage(path, filestats.st_size);
     else
     {
         errno = stat_errno;
         ereport(LOG,
                 (errcode_for_file_access(),
                  errmsg("could not stat file \"%s\": %m", path)));
     }
  
     return true;
 }

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

Referenced by FileSetDelete(), and unlink_if_exists_fname().

◆ PathNameOpenFile()

File PathNameOpenFile	(	const char *	fileName,
		int	fileFlags
	)

Definition at line 1527 of file fd.c.

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

References PathNameOpenFilePerm(), and pg_file_create_mode.

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

◆ PathNameOpenFilePerm()

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

Definition at line 1540 of file fd.c.

 {
     char       *fnamecopy;
     File        file;
     Vfd        *vfdP;
  
     DO_DB(elog(LOG, "PathNameOpenFilePerm: %s %x %o",
                fileName, fileFlags, fileMode));
  
     /*
      * We need a malloc'd copy of the file name; fail cleanly if no room.
      */
     fnamecopy = strdup(fileName);
     if (fnamecopy == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_OUT_OF_MEMORY),
                  errmsg("out of memory")));
  
     file = AllocateVfd();
     vfdP = &VfdCache[file];
  
     /* Close excess kernel FDs. */
     ReleaseLruFiles();
  
     /*
      * Descriptors managed by VFDs are implicitly marked O_CLOEXEC.  The
      * client shouldn't be expected to know which kernel descriptors are
      * currently open, so it wouldn't make sense for them to be inherited by
      * executed subprograms.
      */
     fileFlags |= O_CLOEXEC;
  
     vfdP->fd = BasicOpenFilePerm(fileName, fileFlags, fileMode);
  
     if (vfdP->fd < 0)
     {
         int         save_errno = errno;
  
         FreeVfd(file);
         free(fnamecopy);
         errno = save_errno;
         return -1;
     }
     ++nfile;
     DO_DB(elog(LOG, "PathNameOpenFile: success %d",
                vfdP->fd));
  
     vfdP->fileName = fnamecopy;
     /* Saved flags are adjusted to be OK for re-opening file */
     vfdP->fileFlags = fileFlags & ~(O_CREAT | O_TRUNC | O_EXCL);
     vfdP->fileMode = fileMode;
     vfdP->fileSize = 0;
     vfdP->fdstate = 0x0;
     vfdP->resowner = NULL;
  
     Insert(file);
  
     return file;
 }

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

Referenced by PathNameOpenFile().

◆ PathNameOpenTemporaryFile()

File PathNameOpenTemporaryFile	(	const char *	path,
		int	mode
	)

Definition at line 1853 of file fd.c.

 {
     File        file;
  
     Assert(temporary_files_allowed);    /* check temp file access is up */
  
     ResourceOwnerEnlargeFiles(CurrentResourceOwner);
  
     file = PathNameOpenFile(path, mode | PG_BINARY);
  
     /* If no such file, then we don't raise an error. */
     if (file <= 0 && errno != ENOENT)
         ereport(ERROR,
                 (errcode_for_file_access(),
                  errmsg("could not open temporary file \"%s\": %m",
                         path)));
  
     if (file > 0)
     {
         /* Register it for automatic close. */
         RegisterTemporaryFile(file);
     }
  
     return file;
 }

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

Referenced by FileSetOpen().

◆ pg_fdatasync()

int pg_fdatasync ( int fd )

Definition at line 455 of file fd.c.

 {
     int         rc;
  
     if (!enableFsync)
         return 0;
  
 retry:
     rc = fdatasync(fd);
  
     if (rc == -1 && errno == EINTR)
         goto retry;
  
     return rc;
 }

References EINTR, enableFsync, fd(), and fdatasync().

Referenced by issue_xlog_fsync().

◆ pg_flush_data()

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

Definition at line 477 of file fd.c.

 {
     /*
      * Right now file flushing is primarily used to avoid making later
      * fsync()/fdatasync() calls have less impact. Thus don't trigger flushes
      * if fsyncs are disabled - that's a decision we might want to make
      * configurable at some point.
      */
     if (!enableFsync)
         return;
  
     /*
      * We compile all alternatives that are supported on the current platform,
      * to find portability problems more easily.
      */
 #if defined(HAVE_SYNC_FILE_RANGE)
     {
         int         rc;
         static bool not_implemented_by_kernel = false;
  
         if (not_implemented_by_kernel)
             return;
  
 retry:
  
         /*
          * sync_file_range(SYNC_FILE_RANGE_WRITE), currently linux specific,
          * tells the OS that writeback for the specified blocks should be
          * started, but that we don't want to wait for completion.  Note that
          * this call might block if too much dirty data exists in the range.
          * This is the preferable method on OSs supporting it, as it works
          * reliably when available (contrast to msync()) and doesn't flush out
          * clean data (like FADV_DONTNEED).
          */
         rc = sync_file_range(fd, offset, nbytes,
                              SYNC_FILE_RANGE_WRITE);
         if (rc != 0)
         {
             int         elevel;
  
             if (rc == EINTR)
                 goto retry;
  
             /*
              * For systems that don't have an implementation of
              * sync_file_range() such as Windows WSL, generate only one
              * warning and then suppress all further attempts by this process.
              */
             if (errno == ENOSYS)
             {
                 elevel = WARNING;
                 not_implemented_by_kernel = true;
             }
             else
                 elevel = data_sync_elevel(WARNING);
  
             ereport(elevel,
                     (errcode_for_file_access(),
                      errmsg("could not flush dirty data: %m")));
         }
  
         return;
     }
 #endif
 #if !defined(WIN32) && defined(MS_ASYNC)
     {
         void       *p;
         static int  pagesize = 0;
  
         /*
          * On several OSs msync(MS_ASYNC) on a mmap'ed file triggers
          * writeback. On linux it only does so if MS_SYNC is specified, but
          * then it does the writeback synchronously. Luckily all common linux
          * systems have sync_file_range().  This is preferable over
          * FADV_DONTNEED because it doesn't flush out clean data.
          *
          * We map the file (mmap()), tell the kernel to sync back the contents
          * (msync()), and then remove the mapping again (munmap()).
          */
  
         /* mmap() needs actual length if we want to map whole file */
         if (offset == 0 && nbytes == 0)
         {
             nbytes = lseek(fd, 0, SEEK_END);
             if (nbytes < 0)
             {
                 ereport(WARNING,
                         (errcode_for_file_access(),
                          errmsg("could not determine dirty data size: %m")));
                 return;
             }
         }
  
         /*
          * Some platforms reject partial-page mmap() attempts.  To deal with
          * that, just truncate the request to a page boundary.  If any extra
          * bytes don't get flushed, well, it's only a hint anyway.
          */
  
         /* fetch pagesize only once */
         if (pagesize == 0)
             pagesize = sysconf(_SC_PAGESIZE);
  
         /* align length to pagesize, dropping any fractional page */
         if (pagesize > 0)
             nbytes = (nbytes / pagesize) * pagesize;
  
         /* fractional-page request is a no-op */
         if (nbytes <= 0)
             return;
  
         /*
          * mmap could well fail, particularly on 32-bit platforms where there
          * may simply not be enough address space.  If so, silently fall
          * through to the next implementation.
          */
         if (nbytes <= (off_t) SSIZE_MAX)
             p = mmap(NULL, nbytes, PROT_READ, MAP_SHARED, fd, offset);
         else
             p = MAP_FAILED;
  
         if (p != MAP_FAILED)
         {
             int         rc;
  
             rc = msync(p, (size_t) nbytes, MS_ASYNC);
             if (rc != 0)
             {
                 ereport(data_sync_elevel(WARNING),
                         (errcode_for_file_access(),
                          errmsg("could not flush dirty data: %m")));
                 /* NB: need to fall through to munmap()! */
             }
  
             rc = munmap(p, (size_t) nbytes);
             if (rc != 0)
             {
                 /* FATAL error because mapping would remain */
                 ereport(FATAL,
                         (errcode_for_file_access(),
                          errmsg("could not munmap() while flushing data: %m")));
             }
  
             return;
         }
     }
 #endif
 #if defined(USE_POSIX_FADVISE) && defined(POSIX_FADV_DONTNEED)
     {
         int         rc;
  
         /*
          * Signal the kernel that the passed in range should not be cached
          * anymore. This has the, desired, side effect of writing out dirty
          * data, and the, undesired, side effect of likely discarding useful
          * clean cached blocks.  For the latter reason this is the least
          * preferable method.
          */
  
         rc = posix_fadvise(fd, offset, nbytes, POSIX_FADV_DONTNEED);
  
         if (rc != 0)
         {
             /* don't error out, this is just a performance optimization */
             ereport(WARNING,
                     (errcode_for_file_access(),
                      errmsg("could not flush dirty data: %m")));
         }
  
         return;
     }
 #endif
 }

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

Referenced by copy_file(), and FileWriteback().

◆ pg_fsync()

int pg_fsync ( int fd )

Definition at line 361 of file fd.c.

 {
 #if !defined(WIN32) && defined(USE_ASSERT_CHECKING)
     struct stat st;
  
     /*
      * Some operating system implementations of fsync() have requirements
      * about the file access modes that were used when their file descriptor
      * argument was opened, and these requirements differ depending on whether
      * the file descriptor is for a directory.
      *
      * For any file descriptor that may eventually be handed to fsync(), we
      * should have opened it with access modes that are compatible with
      * fsync() on all supported systems, otherwise the code may not be
      * portable, even if it runs ok on the current system.
      *
      * We assert here that a descriptor for a file was opened with write
      * permissions (either O_RDWR or O_WRONLY) and for a directory without
      * write permissions (O_RDONLY).
      *
      * Ignore any fstat errors and let the follow-up fsync() do its work.
      * Doing this sanity check here counts for the case where fsync() is
      * disabled.
      */
     if (fstat(fd, &st) == 0)
     {
         int         desc_flags = fcntl(fd, F_GETFL);
  
         /*
          * O_RDONLY is historically 0, so just make sure that for directories
          * no write flags are used.
          */
         if (S_ISDIR(st.st_mode))
             Assert((desc_flags & (O_RDWR | O_WRONLY)) == 0);
         else
             Assert((desc_flags & (O_RDWR | O_WRONLY)) != 0);
     }
     errno = 0;
 #endif
  
     /* #if is to skip the sync_method test if there's no need for it */
 #if defined(HAVE_FSYNC_WRITETHROUGH)
     if (sync_method == SYNC_METHOD_FSYNC_WRITETHROUGH)
         return pg_fsync_writethrough(fd);
     else
 #endif
         return pg_fsync_no_writethrough(fd);
 }

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

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

◆ pg_fsync_no_writethrough()

int pg_fsync_no_writethrough ( int fd )

Definition at line 416 of file fd.c.

 {
     int         rc;
  
     if (!enableFsync)
         return 0;
  
 retry:
     rc = fsync(fd);
  
     if (rc == -1 && errno == EINTR)
         goto retry;
  
     return rc;
 }

References EINTR, enableFsync, fd(), and fsync.

Referenced by issue_xlog_fsync(), and pg_fsync().

◆ pg_fsync_writethrough()

int pg_fsync_writethrough ( int fd )

Definition at line 436 of file fd.c.

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

References enableFsync, and fd().

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

◆ pg_ftruncate()

static int pg_ftruncate	(	int	fd,
		off_t	length
	)

static

Definition at line 655 of file fd.c.

 {
     int         ret;
  
 retry:
     ret = ftruncate(fd, length);
  
     if (ret == -1 && errno == EINTR)
         goto retry;
  
     return ret;
 }

References EINTR, fd(), and ftruncate.

Referenced by FileTruncate(), and pg_truncate().

◆ pg_truncate()

int pg_truncate	(	const char *	path,
		off_t	length
	)

Definition at line 672 of file fd.c.

 {
     int         ret;
 #ifdef WIN32
     int         save_errno;
     int         fd;
  
     fd = OpenTransientFile(path, O_RDWR | PG_BINARY);
     if (fd >= 0)
     {
         ret = pg_ftruncate(fd, length);
         save_errno = errno;
         CloseTransientFile(fd);
         errno = save_errno;
     }
     else
         ret = -1;
 #else
  
 retry:
     ret = truncate(path, length);
  
     if (ret == -1 && errno == EINTR)
         goto retry;
 #endif
  
     return ret;
 }

References CloseTransientFile(), EINTR, fd(), OpenTransientFile(), PG_BINARY, and pg_ftruncate().

Referenced by do_truncate().

◆ ReadDir()

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

Definition at line 2854 of file fd.c.

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

References ERROR, and ReadDirExtended().

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

◆ ReadDirExtended()

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

Definition at line 2869 of file fd.c.

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

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

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

◆ RegisterTemporaryFile()

static void RegisterTemporaryFile ( File file )

static

Definition at line 1499 of file fd.c.

 {
     ResourceOwnerRememberFile(CurrentResourceOwner, file);
     VfdCache[file].resowner = CurrentResourceOwner;
  
     /* Backup mechanism for closing at end of xact. */
     VfdCache[file].fdstate |= FD_CLOSE_AT_EOXACT;
     have_xact_temporary_files = true;
 }

References CurrentResourceOwner, FD_CLOSE_AT_EOXACT, vfd::fdstate, have_xact_temporary_files, ResourceOwnerRememberFile(), vfd::resowner, and VfdCache.

Referenced by OpenTemporaryFile(), PathNameCreateTemporaryFile(), and PathNameOpenTemporaryFile().

◆ ReleaseExternalFD()

void ReleaseExternalFD ( void )

Definition at line 1191 of file fd.c.

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

References Assert(), and numExternalFDs.

Referenced by ClosePostmasterPorts(), CreateWaitEventSet(), dsm_impl_posix(), FreeWaitEventSet(), FreeWaitEventSetAfterFork(), InitializeLatchSupport(), libpqsrv_connect_internal(), libpqsrv_disconnect(), and XLogFileClose().

◆ ReleaseLruFile()

static bool ReleaseLruFile ( void )

static

Definition at line 1334 of file fd.c.

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

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

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

◆ ReleaseLruFiles()

static void ReleaseLruFiles ( void )

static

Definition at line 1356 of file fd.c.

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

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

Referenced by AllocateDir(), AllocateFile(), LruInsert(), OpenPipeStream(), OpenTransientFilePerm(), PathNameOpenFilePerm(), and ReserveExternalFD().

◆ RemovePgTempFiles()

void RemovePgTempFiles ( void )

Definition at line 3219 of file fd.c.

 {
     char        temp_path[MAXPGPATH + 10 + sizeof(TABLESPACE_VERSION_DIRECTORY) + sizeof(PG_TEMP_FILES_DIR)];
     DIR        *spc_dir;
     struct dirent *spc_de;
  
     /*
      * First process temp files in pg_default ($PGDATA/base)
      */
     snprintf(temp_path, sizeof(temp_path), "base/%s", PG_TEMP_FILES_DIR);
     RemovePgTempFilesInDir(temp_path, true, false);
     RemovePgTempRelationFiles("base");
  
     /*
      * Cycle through temp directories for all non-default tablespaces.
      */
     spc_dir = AllocateDir("pg_tblspc");
  
     while ((spc_de = ReadDirExtended(spc_dir, "pg_tblspc", LOG)) != NULL)
     {
         if (strcmp(spc_de->d_name, ".") == 0 ||
             strcmp(spc_de->d_name, "..") == 0)
             continue;
  
         snprintf(temp_path, sizeof(temp_path), "pg_tblspc/%s/%s/%s",
                  spc_de->d_name, TABLESPACE_VERSION_DIRECTORY, PG_TEMP_FILES_DIR);
         RemovePgTempFilesInDir(temp_path, true, false);
  
         snprintf(temp_path, sizeof(temp_path), "pg_tblspc/%s/%s",
                  spc_de->d_name, TABLESPACE_VERSION_DIRECTORY);
         RemovePgTempRelationFiles(temp_path);
     }
  
     FreeDir(spc_dir);
  
     /*
      * In EXEC_BACKEND case there is a pgsql_tmp directory at the top level of
      * DataDir as well.  However, that is *not* cleaned here because doing so
      * would create a race condition.  It's done separately, earlier in
      * postmaster startup.
      */
 }

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

Referenced by PostmasterMain(), and PostmasterStateMachine().

◆ RemovePgTempFilesInDir()

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

Definition at line 3278 of file fd.c.

 {
     DIR        *temp_dir;
     struct dirent *temp_de;
     char        rm_path[MAXPGPATH * 2];
  
     temp_dir = AllocateDir(tmpdirname);
  
     if (temp_dir == NULL && errno == ENOENT && missing_ok)
         return;
  
     while ((temp_de = ReadDirExtended(temp_dir, tmpdirname, LOG)) != NULL)
     {
         if (strcmp(temp_de->d_name, ".") == 0 ||
             strcmp(temp_de->d_name, "..") == 0)
             continue;
  
         snprintf(rm_path, sizeof(rm_path), "%s/%s",
                  tmpdirname, temp_de->d_name);
  
         if (unlink_all ||
             strncmp(temp_de->d_name,
                     PG_TEMP_FILE_PREFIX,
                     strlen(PG_TEMP_FILE_PREFIX)) == 0)
         {
             PGFileType  type = get_dirent_type(rm_path, temp_de, false, LOG);
  
             if (type == PGFILETYPE_ERROR)
                 continue;
             else if (type == PGFILETYPE_DIR)
             {
                 /* recursively remove contents, then directory itself */
                 RemovePgTempFilesInDir(rm_path, false, true);
  
                 if (rmdir(rm_path) < 0)
                     ereport(LOG,
                             (errcode_for_file_access(),
                              errmsg("could not remove directory \"%s\": %m",
                                     rm_path)));
             }
             else
             {
                 if (unlink(rm_path) < 0)
                     ereport(LOG,
                             (errcode_for_file_access(),
                              errmsg("could not remove file \"%s\": %m",
                                     rm_path)));
             }
         }
         else
             ereport(LOG,
                     (errmsg("unexpected file found in temporary-files directory: \"%s\"",
                             rm_path)));
     }
  
     FreeDir(temp_dir);
 }

References AllocateDir(), dirent::d_name, ereport, errcode_for_file_access(), errmsg(), FreeDir(), get_dirent_type(), LOG, MAXPGPATH, PG_TEMP_FILE_PREFIX, PGFILETYPE_DIR, PGFILETYPE_ERROR, ReadDirExtended(), snprintf, and type.

Referenced by PostmasterMain(), and RemovePgTempFiles().

◆ RemovePgTempRelationFiles()

static void RemovePgTempRelationFiles ( const char * tsdirname )

static

Definition at line 3338 of file fd.c.

 {
     DIR        *ts_dir;
     struct dirent *de;
     char        dbspace_path[MAXPGPATH * 2];
  
     ts_dir = AllocateDir(tsdirname);
  
     while ((de = ReadDirExtended(ts_dir, tsdirname, LOG)) != NULL)
     {
         /*
          * We're only interested in the per-database directories, which have
          * numeric names.  Note that this code will also (properly) ignore "."
          * and "..".
          */
         if (strspn(de->d_name, "0123456789") != strlen(de->d_name))
             continue;
  
         snprintf(dbspace_path, sizeof(dbspace_path), "%s/%s",
                  tsdirname, de->d_name);
         RemovePgTempRelationFilesInDbspace(dbspace_path);
     }
  
     FreeDir(ts_dir);
 }

References AllocateDir(), dirent::d_name, FreeDir(), LOG, MAXPGPATH, ReadDirExtended(), RemovePgTempRelationFilesInDbspace(), and snprintf.

Referenced by RemovePgTempFiles().

◆ RemovePgTempRelationFilesInDbspace()

static void RemovePgTempRelationFilesInDbspace ( const char * dbspacedirname )

static

Definition at line 3366 of file fd.c.

 {
     DIR        *dbspace_dir;
     struct dirent *de;
     char        rm_path[MAXPGPATH * 2];
  
     dbspace_dir = AllocateDir(dbspacedirname);
  
     while ((de = ReadDirExtended(dbspace_dir, dbspacedirname, LOG)) != NULL)
     {
         if (!looks_like_temp_rel_name(de->d_name))
             continue;
  
         snprintf(rm_path, sizeof(rm_path), "%s/%s",
                  dbspacedirname, de->d_name);
  
         if (unlink(rm_path) < 0)
             ereport(LOG,
                     (errcode_for_file_access(),
                      errmsg("could not remove file \"%s\": %m",
                             rm_path)));
     }
  
     FreeDir(dbspace_dir);
 }

References AllocateDir(), dirent::d_name, ereport, errcode_for_file_access(), errmsg(), FreeDir(), LOG, looks_like_temp_rel_name(), MAXPGPATH, ReadDirExtended(), and snprintf.

Referenced by RemovePgTempRelationFiles().

◆ ReportTemporaryFileUsage()

static void ReportTemporaryFileUsage	(	const char *	path,
		off_t	size
	)

static

Definition at line 1480 of file fd.c.

 {
     pgstat_report_tempfile(size);
  
     if (log_temp_files >= 0)
     {
         if ((size / 1024) >= log_temp_files)
             ereport(LOG,
                     (errmsg("temporary file: path \"%s\", size %lu",
                             path, (unsigned long) size)));
     }
 }

References ereport, errmsg(), LOG, log_temp_files, and pgstat_report_tempfile().

Referenced by FileClose(), and PathNameDeleteTemporaryFile().

◆ reserveAllocatedDesc()

static bool reserveAllocatedDesc ( void )

static

Definition at line 2453 of file fd.c.

 {
     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 / 3 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 / 3;
         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 / 3.  (This should certainly be at
      * least as large as the initial size, FD_MINFREE / 3, so we aren't
      * tightening the restriction here.)  Recall that "external" FDs are
      * allowed to consume another third of max_safe_fds.
      */
     newMax = max_safe_fds / 3;
     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;
 }

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

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

◆ ReserveExternalFD()

void ReserveExternalFD ( void )

Definition at line 1173 of file fd.c.

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

References numExternalFDs, and ReleaseLruFiles().

Referenced by AcquireExternalFD(), BackendInitialize(), dsm_impl_posix(), InitializeLatchSupport(), InitPostmasterDeathWatchHandle(), and XLogWrite().

◆ set_max_safe_fds()

void set_max_safe_fds ( void )

Definition at line 996 of file fd.c.

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

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().

◆ SetTempTablespaces()

void SetTempTablespaces	(	Oid *	tableSpaces,
		int	numSpaces
	)

Definition at line 2994 of file fd.c.

 {
     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 = pg_prng_uint64_range(&pg_global_prng_state,
                                                   0, numSpaces - 1);
     else
         nextTempTableSpace = 0;
 }

References Assert(), nextTempTableSpace, numTempTableSpaces, pg_global_prng_state, pg_prng_uint64_range(), and tempTableSpaces.

Referenced by assign_temp_tablespaces(), and PrepareTempTablespaces().

◆ SyncDataDirectory()

void SyncDataDirectory ( void )

Definition at line 3489 of file fd.c.

 {
     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;
  
     {
         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;
     }
  
 #ifdef HAVE_SYNCFS
     if (recovery_init_sync_method == DATA_DIR_SYNC_METHOD_SYNCFS)
     {
         DIR        *dir;
         struct dirent *de;
  
         /*
          * On Linux, we don't have to open every single file one by one.  We
          * can use syncfs() to sync whole filesystems.  We only expect
          * filesystem boundaries to exist where we tolerate symlinks, namely
          * pg_wal and the tablespaces, so we call syncfs() for each of those
          * directories.
          */
  
         /* Prepare to report progress syncing the data directory via syncfs. */
         begin_startup_progress_phase();
  
         /* Sync the top level pgdata directory. */
         do_syncfs(".");
         /* If any tablespaces are configured, sync each of those. */
         dir = AllocateDir("pg_tblspc");
         while ((de = ReadDirExtended(dir, "pg_tblspc", LOG)))
         {
             char        path[MAXPGPATH];
  
             if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0)
                 continue;
  
             snprintf(path, MAXPGPATH, "pg_tblspc/%s", de->d_name);
             do_syncfs(path);
         }
         FreeDir(dir);
         /* If pg_wal is a symlink, process that too. */
         if (xlog_is_symlink)
             do_syncfs("pg_wal");
         return;
     }
 #endif                          /* !HAVE_SYNCFS */
  
 #ifdef PG_FLUSH_DATA_WORKS
     /* Prepare to report progress of the pre-fsync phase. */
     begin_startup_progress_phase();
  
     /*
      * 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.
      */
     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
  
     /* Prepare to report progress syncing the data directory via fsync. */
     begin_startup_progress_phase();
  
     /*
      * 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);
 }

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

Referenced by StartupXLOG().

◆ TempTablespacePath()

void TempTablespacePath	(	char *	path,
		Oid	tablespace
	)

Definition at line 1731 of file fd.c.

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

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

Referenced by FileSetCreate(), FileSetPath(), OpenTemporaryFileInTablespace(), and pg_ls_tmpdir().

◆ TempTablespacesAreSet()

bool TempTablespacesAreSet ( void )

Definition at line 3023 of file fd.c.

 {
     return (numTempTableSpaces >= 0);
 }

References numTempTableSpaces.

Referenced by GetTempTablespaces(), and PrepareTempTablespaces().

◆ unlink_if_exists_fname()

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

static

Definition at line 3717 of file fd.c.

 {
     if (isdir)
     {
         if (rmdir(fname) != 0 && errno != ENOENT)
             ereport(elevel,
                     (errcode_for_file_access(),
                      errmsg("could not remove directory \"%s\": %m", fname)));
     }
     else
     {
         /* Use PathNameDeleteTemporaryFile to report filesize */
         PathNameDeleteTemporaryFile(fname, false);
     }
 }

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

Referenced by PathNameDeleteTemporaryDir().

◆ walkdir()

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

static

Definition at line 3603 of file fd.c.

 {
     DIR        *dir;
     struct dirent *de;
  
     dir = AllocateDir(path);
  
     while ((de = ReadDirExtended(dir, path, elevel)) != NULL)
     {
         char        subpath[MAXPGPATH * 2];
  
         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);
  
         switch (get_dirent_type(subpath, de, process_symlinks, elevel))
         {
             case PGFILETYPE_REG:
                 (*action) (subpath, false, elevel);
                 break;
             case PGFILETYPE_DIR:
                 walkdir(subpath, action, false, elevel);
                 break;
             default:
  
                 /*
                  * Errors are already reported directly by get_dirent_type(),
                  * and any remaining symlinks and unknown file types are
                  * ignored.
                  */
                 break;
         }
     }
  
     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.  However, skip this if AllocateDir failed; the action function
      * might not be robust against that.
      */
     if (dir)
         (*action) (path, true, elevel);
 }

References generate_unaccent_rules::action, AllocateDir(), CHECK_FOR_INTERRUPTS, dirent::d_name, FreeDir(), get_dirent_type(), MAXPGPATH, PGFILETYPE_DIR, PGFILETYPE_REG, ReadDirExtended(), snprintf, and subpath().

Referenced by PathNameDeleteTemporaryDir(), and SyncDataDirectory().

Variable Documentation

◆ allocatedDescs

AllocateDesc* allocatedDescs = NULL

static

Definition at line 269 of file fd.c.

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

◆ data_sync_retry

bool data_sync_retry = false

Definition at line 162 of file fd.c.

Referenced by data_sync_elevel().

◆ have_xact_temporary_files

bool have_xact_temporary_files = false

static

Definition at line 228 of file fd.c.

Referenced by CleanupTempFiles(), and RegisterTemporaryFile().

◆ io_direct_flags

int io_direct_flags

Definition at line 168 of file fd.c.

Referenced by _mdfd_open_flags(), assign_debug_io_direct(), get_sync_bit(), mdprefetch(), mdwriteback(), PrefetchLocalBuffer(), PrefetchSharedBuffer(), ScheduleBufferTagForWriteback(), XLogFileClose(), XLogFileInitInternal(), and XLogPrefetcherNextBlock().

◆ max_files_per_process

int max_files_per_process = 1000

Definition at line 146 of file fd.c.

Referenced by set_max_safe_fds().

◆ max_safe_fds

int max_safe_fds = FD_MINFREE

Definition at line 159 of file fd.c.

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

◆ maxAllocatedDescs

int maxAllocatedDescs = 0

static

Definition at line 268 of file fd.c.

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

◆ nextTempTableSpace

int nextTempTableSpace = 0

static

Definition at line 290 of file fd.c.

Referenced by GetNextTempTableSpace(), and SetTempTablespaces().

◆ nfile

int nfile = 0

static

Definition at line 222 of file fd.c.

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

◆ numAllocatedDescs

int numAllocatedDescs = 0

static

Definition at line 267 of file fd.c.

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

◆ numExternalFDs

int numExternalFDs = 0

static

Definition at line 274 of file fd.c.

Referenced by AcquireExternalFD(), ReleaseExternalFD(), ReleaseLruFiles(), and ReserveExternalFD().

◆ numTempTableSpaces

int numTempTableSpaces = -1

static

Definition at line 289 of file fd.c.

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

◆ recovery_init_sync_method

int recovery_init_sync_method = DATA_DIR_SYNC_METHOD_FSYNC

Definition at line 165 of file fd.c.

Referenced by SyncDataDirectory().

◆ SizeVfdCache

Size SizeVfdCache = 0

static

Definition at line 217 of file fd.c.

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

◆ tempFileCounter

long tempFileCounter = 0

static

Definition at line 280 of file fd.c.

Referenced by OpenTemporaryFileInTablespace().

◆ temporary_files_size

uint64 temporary_files_size = 0

static

Definition at line 236 of file fd.c.

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

◆ tempTableSpaces

Oid* tempTableSpaces = NULL

static

Definition at line 288 of file fd.c.

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

◆ VfdCache

Vfd* VfdCache

static

Definition at line 216 of file fd.c.

Referenced by AllocateVfd(), CleanupTempFiles(), Delete(), FileAccess(), FileClose(), FileFallocate(), FileGetRawDesc(), FileGetRawFlags(), FileGetRawMode(), FilePathName(), FilePrefetch(), FileRead(), FileSize(), FileSync(), FileTruncate(), FileWrite(), FileWriteback(), FileZero(), FreeVfd(), InitFileAccess(), Insert(), LruDelete(), LruInsert(), OpenTemporaryFile(), PathNameCreateTemporaryFile(), PathNameOpenFilePerm(), RegisterTemporaryFile(), and ReleaseLruFile().

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ DO_DB

◆ FD_CLOSE_AT_EOXACT

◆ FD_DELETE_AT_CLOSE

◆ FD_MINFREE

◆ FD_TEMP_FILE_LIMIT

◆ FileIsNotOpen

◆ FileIsValid

◆ NUM_RESERVED_FDS

◆ VFD_CLOSED

Typedef Documentation

◆ Vfd

Enumeration Type Documentation

◆ AllocateDescKind

Function Documentation

◆ AcquireExternalFD()

◆ AllocateDir()

◆ AllocateFile()

◆ AllocateVfd()

◆ assign_debug_io_direct()

◆ AtEOSubXact_Files()

◆ AtEOXact_Files()

◆ BasicOpenFile()

◆ BasicOpenFilePerm()

◆ BeforeShmemExit_Files()

◆ check_debug_io_direct()

◆ CleanupTempFiles()

◆ closeAllVfds()

◆ ClosePipeStream()

◆ CloseTransientFile()

◆ count_usable_fds()

◆ data_sync_elevel()

◆ datadir_fsync_fname()

◆ Delete()

◆ durable_rename()

◆ durable_unlink()

◆ FileAccess()

◆ FileClose()

◆ FileFallocate()

◆ FileGetRawDesc()

◆ FileGetRawFlags()

◆ FileGetRawMode()

◆ FilePathName()

◆ FilePrefetch()

◆ FileRead()

◆ FileSize()

◆ FileSync()

◆ FileTruncate()

◆ FileWrite()

◆ FileWriteback()

◆ FileZero()

◆ FreeDesc()

◆ FreeDir()

◆ FreeFile()

◆ FreeVfd()

◆ fsync_fname()

◆ fsync_fname_ext()

◆ fsync_parent_path()

◆ GetNextTempTableSpace()

◆ GetTempTablespaces()

◆ InitFileAccess()

◆ InitTemporaryFileAccess()

◆ Insert()

◆ looks_like_temp_rel_name()

◆ LruDelete()

◆ LruInsert()

◆ MakePGDirectory()

◆ OpenPipeStream()

◆ OpenTemporaryFile()

◆ OpenTemporaryFileInTablespace()

◆ OpenTransientFile()

◆ OpenTransientFilePerm()

◆ PathNameCreateTemporaryDir()

◆ PathNameCreateTemporaryFile()