file_utils.c File Reference

#include "postgres.h"
#include <dirent.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include "common/file_utils.h"
#include "port/pg_iovec.h"

Include dependency graph for file_utils.c:

Go to the source code of this file.

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, off_t offset)

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,
		off_t	offset
	)

Definition at line 541 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 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().