file_utils.h File Reference

#include <dirent.h>

Include dependency graph for file_utils.h:

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

Go to the source code of this file.

Macros
#define	PG_TEMP_FILES_DIR   "pgsql_tmp"
#define	PG_TEMP_FILE_PREFIX   "pgsql_tmp"

Typedefs
typedef enum PGFileType	PGFileType
typedef enum DataDirSyncMethod	DataDirSyncMethod

Enumerations
enum	PGFileType {   PGFILETYPE_ERROR , PGFILETYPE_UNKNOWN , PGFILETYPE_REG , PGFILETYPE_DIR ,   PGFILETYPE_LNK }
enum	DataDirSyncMethod { DATA_DIR_SYNC_METHOD_FSYNC , DATA_DIR_SYNC_METHOD_SYNCFS }

Functions
PGFileType	get_dirent_type (const char *path, const struct dirent *de, bool look_through_symlinks, int elevel)
int	compute_remaining_iovec (struct iovec *destination, const struct iovec *source, int iovcnt, size_t transferred)
ssize_t	pg_pwritev_with_retry (int fd, const struct iovec *iov, int iovcnt, off_t offset)
ssize_t	pg_pwrite_zeros (int fd, size_t size, off_t offset)

Macro Definition Documentation

PG_TEMP_FILE_PREFIX

#define PG_TEMP_FILE_PREFIX   "pgsql_tmp"

Definition at line 64 of file file_utils.h.

PG_TEMP_FILES_DIR

#define PG_TEMP_FILES_DIR   "pgsql_tmp"

Definition at line 63 of file file_utils.h.

Typedef Documentation

DataDirSyncMethod

typedef enum DataDirSyncMethod DataDirSyncMethod

PGFileType

typedef enum PGFileType PGFileType

Enumeration Type Documentation

DataDirSyncMethod

enum DataDirSyncMethod

Enumerator
DATA_DIR_SYNC_METHOD_FSYNC
DATA_DIR_SYNC_METHOD_SYNCFS

Definition at line 27 of file file_utils.h.

{
    DATA_DIR_SYNC_METHOD_FSYNC,
    DATA_DIR_SYNC_METHOD_SYNCFS,
} DataDirSyncMethod;

PGFileType

enum PGFileType

Enumerator
PGFILETYPE_ERROR
PGFILETYPE_UNKNOWN
PGFILETYPE_REG
PGFILETYPE_DIR
PGFILETYPE_LNK

Definition at line 18 of file file_utils.h.

{
    PGFILETYPE_ERROR,
    PGFILETYPE_UNKNOWN,
    PGFILETYPE_REG,
    PGFILETYPE_DIR,
    PGFILETYPE_LNK,
} PGFileType;

Function Documentation

compute_remaining_iovec()

int compute_remaining_iovec	(	struct iovec *	destination,
		const struct iovec *	source,
		int	iovcnt,
		size_t	transferred
	)

Definition at line 614 of file file_utils.c.

{
    Assert(iovcnt > 0);
 
    /* Skip wholly transferred iovecs. */
    while (source->iov_len <= transferred)
    {
        transferred -= source->iov_len;
        source++;
        iovcnt--;
 
        /* All iovecs transferred? */
        if (iovcnt == 0)
        {
            /*
             * We don't expect the kernel to transfer more than we asked it
             * to, or something is out of sync.
             */
            Assert(transferred == 0);
            return 0;
        }
    }
 
    /* Copy the remaining iovecs to the front of the array. */
    if (source != destination)
        memmove(destination, source, sizeof(*source) * iovcnt);
 
    /* Adjust leading iovec, which may have been partially transferred. */
    Assert(destination->iov_len > transferred);
    destination->iov_base = (char *) destination->iov_base + transferred;
    destination->iov_len -= transferred;
 
    return iovcnt;
}

References Assert(), and source.

Referenced by mdreadv(), mdwritev(), and pg_pwritev_with_retry().

get_dirent_type()

PGFileType get_dirent_type	(	const char *	path,
		const struct dirent *	de,
		bool	look_through_symlinks,
		int	elevel
	)

Definition at line 547 of file file_utils.c.

{
    PGFileType  result;
 
    /*
     * Some systems tell us the type directly in the dirent struct, but that's
     * a BSD and Linux extension not required by POSIX.  Even when the
     * interface is present, sometimes the type is unknown, depending on the
     * filesystem.
     */
#if defined(DT_REG) && defined(DT_DIR) && defined(DT_LNK)
    if (de->d_type == DT_REG)
        result = PGFILETYPE_REG;
    else if (de->d_type == DT_DIR)
        result = PGFILETYPE_DIR;
    else if (de->d_type == DT_LNK && !look_through_symlinks)
        result = PGFILETYPE_LNK;
    else
        result = PGFILETYPE_UNKNOWN;
#else
    result = PGFILETYPE_UNKNOWN;
#endif
 
    if (result == PGFILETYPE_UNKNOWN)
    {
        struct stat fst;
        int         sret;
 
 
        if (look_through_symlinks)
            sret = stat(path, &fst);
        else
            sret = lstat(path, &fst);
 
        if (sret < 0)
        {
            result = PGFILETYPE_ERROR;
#ifdef FRONTEND
            pg_log_generic(elevel, PG_LOG_PRIMARY, "could not stat file \"%s\": %m", path);
#else
            ereport(elevel,
                    (errcode_for_file_access(),
                     errmsg("could not stat file \"%s\": %m", path)));
#endif
        }
        else if (S_ISREG(fst.st_mode))
            result = PGFILETYPE_REG;
        else if (S_ISDIR(fst.st_mode))
            result = PGFILETYPE_DIR;
        else if (S_ISLNK(fst.st_mode))
            result = PGFILETYPE_LNK;
    }
 
    return result;
}

References dirent::d_type, DT_DIR, DT_LNK, DT_REG, ereport, errcode_for_file_access(), errmsg(), lstat, pg_log_generic(), PG_LOG_PRIMARY, PGFILETYPE_DIR, PGFILETYPE_ERROR, PGFILETYPE_LNK, PGFILETYPE_REG, PGFILETYPE_UNKNOWN, S_ISDIR, S_ISLNK, S_ISREG, stat::st_mode, and stat.

Referenced by CheckPointLogicalRewriteHeap(), CheckPointSnapBuild(), CheckTablespaceDirectory(), copydir(), do_pg_backup_start(), GetConfFilesInDir(), pg_tzenumerate_next(), process_directory_recursively(), RemovePgTempFilesInDir(), RemoveXlogFile(), rmtree(), scan_for_existing_tablespaces(), StartupReplicationSlots(), swap_catalog_files(), and walkdir().

pg_pwrite_zeros()

ssize_t pg_pwrite_zeros	(	int	fd,
		size_t	size,
		off_t	offset
	)

Definition at line 709 of file file_utils.c.

{
    static const PGIOAlignedBlock zbuffer = {0};    /* worth BLCKSZ */
    void       *zerobuf_addr = unconstify(PGIOAlignedBlock *, &zbuffer)->data;
    struct iovec iov[PG_IOV_MAX];
    size_t      remaining_size = size;
    ssize_t     total_written = 0;
 
    /* Loop, writing as many blocks as we can for each system call. */
    while (remaining_size > 0)
    {
        int         iovcnt = 0;
        ssize_t     written;
 
        for (; iovcnt < PG_IOV_MAX && remaining_size > 0; iovcnt++)
        {
            size_t      this_iov_size;
 
            iov[iovcnt].iov_base = zerobuf_addr;
 
            if (remaining_size < BLCKSZ)
                this_iov_size = remaining_size;
            else
                this_iov_size = BLCKSZ;
 
            iov[iovcnt].iov_len = this_iov_size;
            remaining_size -= this_iov_size;
        }
 
        written = pg_pwritev_with_retry(fd, iov, iovcnt, offset);
 
        if (written < 0)
            return written;
 
        offset += written;
        total_written += written;
    }
 
    Assert(total_written == size);
 
    return total_written;
}

References Assert(), fd(), PG_IOV_MAX, pg_pwritev_with_retry(), and unconstify.

Referenced by dir_open_for_write(), FileZero(), and XLogFileInitInternal().

pg_pwritev_with_retry()

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

Definition at line 659 of file file_utils.c.

{
    struct iovec iov_copy[PG_IOV_MAX];
    ssize_t     sum = 0;
    ssize_t     part;
 
    /* We'd better have space to make a copy, in case we need to retry. */
    if (iovcnt > PG_IOV_MAX)
    {
        errno = EINVAL;
        return -1;
    }
 
    do
    {
        /* Write as much as we can. */
        part = pg_pwritev(fd, iov, iovcnt, offset);
        if (part < 0)
            return -1;
 
#ifdef SIMULATE_SHORT_WRITE
        part = Min(part, 4096);
#endif
 
        /* Count our progress. */
        sum += part;
        offset += part;
 
        /*
         * See what is left.  On the first loop we used the caller's array,
         * but in later loops we'll use our local copy that we are allowed to
         * mutate.
         */
        iovcnt = compute_remaining_iovec(iov_copy, iov, iovcnt, part);
        iov = iov_copy;
    } while (iovcnt > 0);
 
    return sum;
}

References compute_remaining_iovec(), fd(), Min, PG_IOV_MAX, and pg_pwritev().

Referenced by pg_pwrite_zeros().