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

Functions
int	fsync_fname (const char fname, bool isdir, const char progname)

void	fsync_pgdata (const char pg_data, const char progname, int serverVersion)

void	fsync_dir_recurse (const char dir, const char progname)

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

int	fsync_parent_path (const char fname, const char progname)

Function Documentation

◆ durable_rename()

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

Definition at line 348 of file file_utils.c.

References _, close, fd(), fsync, fsync_fname(), fsync_parent_path(), PG_BINARY, and strerror().

 {
     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(oldfile, false, progname) != 0)
         return -1;
 
     fd = open(newfile, PG_BINARY | O_RDWR, 0);
     if (fd < 0)
     {
         if (errno != ENOENT)
         {
             fprintf(stderr, _("%s: could not open file \"%s\": %s\n"),
                     progname, newfile, strerror(errno));
             return -1;
         }
     }
     else
     {
         if (fsync(fd) != 0)
         {
             fprintf(stderr, _("%s: could not fsync file \"%s\": %s\n"),
                     progname, newfile, strerror(errno));
             close(fd);
             return -1;
         }
         close(fd);
     }
 
     /* Time to do the real deal... */
     if (rename(oldfile, newfile) != 0)
     {
         fprintf(stderr, _("%s: could not rename file \"%s\" to \"%s\": %s\n"),
                 progname, oldfile, newfile, strerror(errno));
         return -1;
     }
 
     /*
      * To guarantee renaming the file is persistent, fsync the file with its
      * new name, and its containing directory.
      */
     if (fsync_fname(newfile, false, progname) != 0)
         return -1;
 
     if (fsync_parent_path(newfile, progname) != 0)
         return -1;
 
     return 0;
 }

◆ fsync_dir_recurse()

void fsync_dir_recurse	(	const char *	dir,
		const char *	progname
	)

Definition at line 124 of file file_utils.c.

References fsync_fname(), and walkdir().

Referenced by _CloseArchive().

 {
     /*
      * If possible, hint to the kernel that we're soon going to fsync the data
      * directory and its contents.
      */
 #ifdef PG_FLUSH_DATA_WORKS
     walkdir(dir, pre_sync_fname, false, progname);
 #endif
 
     walkdir(dir, fsync_fname, false, progname);
 }

◆ fsync_fname()

int fsync_fname	(	const char *	fname,
		bool	isdir,
		const char *	progname
	)

Definition at line 263 of file file_utils.c.

References _, close, fd(), fsync, PG_BINARY, and strerror().

Referenced by durable_rename(), fsync_dir_recurse(), fsync_parent_path(), and fsync_pgdata().

 {
     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;
 
     /*
      * Open the file, silently ignoring errors about unreadable files (or
      * unsupported operations, e.g. opening a directory under Windows), and
      * logging others.
      */
     fd = open(fname, flags);
     if (fd < 0)
     {
         if (errno == EACCES || (isdir && errno == EISDIR))
             return 0;
         fprintf(stderr, _("%s: could not open file \"%s\": %s\n"),
                 progname, fname, strerror(errno));
         return -1;
     }
 
     returncode = fsync(fd);
 
     /*
      * Some OSes don't allow us to fsync directories at all, so we can ignore
      * those errors. Anything else needs to be reported.
      */
     if (returncode != 0 && !(isdir && errno == EBADF))
     {
         fprintf(stderr, _("%s: could not fsync file \"%s\": %s\n"),
                 progname, fname, strerror(errno));
         (void) close(fd);
         return -1;
     }
 
     (void) close(fd);
     return 0;
 }

◆ fsync_parent_path()

int fsync_parent_path	(	const char *	fname,
		const char *	progname
	)

Definition at line 321 of file file_utils.c.

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

Referenced by durable_rename().

 {
     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(parentpath, true, progname) != 0)
         return -1;
 
     return 0;
 }

◆ fsync_pgdata()

void fsync_pgdata	(	const char *	pg_data,
		const char *	progname,
		int	serverVersion
	)

Definition at line 58 of file file_utils.c.

References _, fsync_fname(), lstat, MAXPGPATH, MINIMUM_VERSION_FOR_PG_WAL, pgwin32_is_junction(), snprintf(), stat, strerror(), and walkdir().

Referenced by BaseBackup(), and main().