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.

Typedefs
typedef enum PGFileType	PGFileType

Enumerations
enum	PGFileType {   PGFILETYPE_ERROR , PGFILETYPE_UNKNOWN , PGFILETYPE_REG , PGFILETYPE_DIR ,   PGFILETYPE_LNK }

Functions
PGFileType	get_dirent_type (const char *path, const struct dirent *de, bool look_through_symlinks, int elevel)
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)

Typedef Documentation

PGFileType

typedef enum PGFileType PGFileType

Enumeration Type Documentation

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

get_dirent_type()

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

Definition at line 406 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(), RemovePgTempFilesInDir(), RemoveXlogFile(), rmtree(), StartupReplicationSlots(), and walkdir().

pg_pwrite_zeros()

ssize_t pg_pwrite_zeros	(	int	fd,
		size_t	size
	)

Definition at line 540 of file file_utils.c.

{
    PGAlignedBlock zbuffer;     /* worth BLCKSZ */
    size_t      zbuffer_sz;
    struct iovec iov[PG_IOV_MAX];
    int         blocks;
    size_t      remaining_size = 0;
    int         i;
    ssize_t     written;
    ssize_t     total_written = 0;
 
    zbuffer_sz = sizeof(zbuffer.data);
 
    /* Zero-fill the buffer. */
    memset(zbuffer.data, 0, zbuffer_sz);
 
    /* Prepare to write out a lot of copies of our zero buffer at once. */
    for (i = 0; i < lengthof(iov); ++i)
    {
        iov[i].iov_base = zbuffer.data;
        iov[i].iov_len = zbuffer_sz;
    }
 
    /* Loop, writing as many blocks as we can for each system call. */
    blocks = size / zbuffer_sz;
    remaining_size = size % zbuffer_sz;
    for (i = 0; i < blocks;)
    {
        int         iovcnt = Min(blocks - i, lengthof(iov));
        off_t       offset = i * zbuffer_sz;
 
        written = pg_pwritev_with_retry(fd, iov, iovcnt, offset);
 
        if (written < 0)
            return written;
 
        i += iovcnt;
        total_written += written;
    }
 
    /* Now, write the remaining size, if any, of the file with zeros. */
    if (remaining_size > 0)
    {
        /* We'll never write more than one block here */
        int         iovcnt = 1;
 
        /* Jump on to the end of previously written blocks */
        off_t       offset = i * zbuffer_sz;
 
        iov[0].iov_len = remaining_size;
 
        written = pg_pwritev_with_retry(fd, iov, iovcnt, offset);
 
        if (written < 0)
            return written;
 
        total_written += written;
    }
 
    Assert(total_written == size);
 
    return total_written;
}

References Assert(), PGAlignedBlock::data, fd(), i, lengthof, Min, PG_IOV_MAX, and pg_pwritev_with_retry().

Referenced by dir_open_for_write(), 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 472 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;
    }
 
    for (;;)
    {
        /* Write as much as we can. */
        part = pg_pwritev(fd, iov, iovcnt, offset);
        if (part < 0)
            return -1;
 
#ifdef SIMULATE_SHORT_WRITE
        part = Min(part, 4096);
#endif
 
        /* Count our progress. */
        sum += part;
        offset += part;
 
        /* Step over iovecs that are done. */
        while (iovcnt > 0 && iov->iov_len <= part)
        {
            part -= iov->iov_len;
            ++iov;
            --iovcnt;
        }
 
        /* Are they all done? */
        if (iovcnt == 0)
        {
            /* We don't expect the kernel to write more than requested. */
            Assert(part == 0);
            break;
        }
 
        /*
         * Move whatever's left to the front of our mutable copy and adjust
         * the leading iovec.
         */
        Assert(iovcnt > 0);
        memmove(iov_copy, iov, sizeof(*iov) * iovcnt);
        Assert(iov->iov_len > part);
        iov_copy[0].iov_base = (char *) iov_copy[0].iov_base + part;
        iov_copy[0].iov_len -= part;
        iov = iov_copy;
    }
 
    return sum;
}

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

Referenced by pg_pwrite_zeros().