md.c File Reference

#include "postgres.h"
#include <unistd.h>
#include <fcntl.h>
#include <sys/file.h>
#include "access/xlog.h"
#include "access/xlogutils.h"
#include "commands/tablespace.h"
#include "miscadmin.h"
#include "pg_trace.h"
#include "pgstat.h"
#include "postmaster/bgwriter.h"
#include "storage/bufmgr.h"
#include "storage/fd.h"
#include "storage/md.h"
#include "storage/relfilelocator.h"
#include "storage/smgr.h"
#include "storage/sync.h"
#include "utils/hsearch.h"
#include "utils/memutils.h"

Include dependency graph for md.c:

Go to the source code of this file.

Data Structures
struct	_MdfdVec

Macros
#define	INIT_MD_FILETAG(a, xx_rlocator, xx_forknum, xx_segno)
#define	EXTENSION_FAIL   (1 << 0)
#define	EXTENSION_RETURN_NULL   (1 << 1)
#define	EXTENSION_CREATE   (1 << 2)
#define	EXTENSION_CREATE_RECOVERY   (1 << 3)
#define	EXTENSION_DONT_CHECK_SIZE   (1 << 4)
#define	EXTENSION_DONT_OPEN   (1 << 5)

Typedefs
typedef struct _MdfdVec	MdfdVec

Functions
static void	mdunlinkfork (RelFileLocatorBackend rlocator, ForkNumber forknum, bool isRedo)
static MdfdVec *	mdopenfork (SMgrRelation reln, ForkNumber forknum, int behavior)
static void	register_dirty_segment (SMgrRelation reln, ForkNumber forknum, MdfdVec *seg)
static void	register_unlink_segment (RelFileLocatorBackend rlocator, ForkNumber forknum, BlockNumber segno)
static void	register_forget_request (RelFileLocatorBackend rlocator, ForkNumber forknum, BlockNumber segno)
static void	_fdvec_resize (SMgrRelation reln, ForkNumber forknum, int nseg)
static char *	_mdfd_segpath (SMgrRelation reln, ForkNumber forknum, BlockNumber segno)
static MdfdVec *	_mdfd_openseg (SMgrRelation reln, ForkNumber forknum, BlockNumber segno, int oflags)
static MdfdVec *	_mdfd_getseg (SMgrRelation reln, ForkNumber forknum, BlockNumber blkno, bool skipFsync, int behavior)
static BlockNumber	_mdnblocks (SMgrRelation reln, ForkNumber forknum, MdfdVec *seg)
void	mdinit (void)
bool	mdexists (SMgrRelation reln, ForkNumber forknum)
void	mdcreate (SMgrRelation reln, ForkNumber forknum, bool isRedo)
void	mdunlink (RelFileLocatorBackend rlocator, ForkNumber forknum, bool isRedo)
static int	do_truncate (const char *path)
void	mdextend (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer, bool skipFsync)
void	mdopen (SMgrRelation reln)
void	mdclose (SMgrRelation reln, ForkNumber forknum)
bool	mdprefetch (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum)
void	mdwriteback (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, BlockNumber nblocks)
void	mdread (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer)
void	mdwrite (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer, bool skipFsync)
BlockNumber	mdnblocks (SMgrRelation reln, ForkNumber forknum)
void	mdtruncate (SMgrRelation reln, ForkNumber forknum, BlockNumber nblocks)
void	mdimmedsync (SMgrRelation reln, ForkNumber forknum)
void	ForgetDatabaseSyncRequests (Oid dbid)
void	DropRelationFiles (RelFileLocator *delrels, int ndelrels, bool isRedo)
int	mdsyncfiletag (const FileTag *ftag, char *path)
int	mdunlinkfiletag (const FileTag *ftag, char *path)
bool	mdfiletagmatches (const FileTag *ftag, const FileTag *candidate)

Variables
static MemoryContext	MdCxt

Macro Definition Documentation

EXTENSION_CREATE

#define EXTENSION_CREATE   (1 << 2)

Definition at line 108 of file md.c.

EXTENSION_CREATE_RECOVERY

#define EXTENSION_CREATE_RECOVERY   (1 << 3)

Definition at line 110 of file md.c.

EXTENSION_DONT_CHECK_SIZE

#define EXTENSION_DONT_CHECK_SIZE   (1 << 4)

Definition at line 118 of file md.c.

EXTENSION_DONT_OPEN

#define EXTENSION_DONT_OPEN   (1 << 5)

Definition at line 120 of file md.c.

EXTENSION_FAIL

#define EXTENSION_FAIL   (1 << 0)

Definition at line 104 of file md.c.

EXTENSION_RETURN_NULL

#define EXTENSION_RETURN_NULL   (1 << 1)

Definition at line 106 of file md.c.

INIT_MD_FILETAG

#define INIT_MD_FILETAG	(		a,
			xx_rlocator,
			xx_forknum,
			xx_segno
	)

Value:

( \
    memset(&(a), 0, sizeof(FileTag)), \
    (a).handler = SYNC_HANDLER_MD, \
    (a).rlocator = (xx_rlocator), \
    (a).forknum = (xx_forknum), \
    (a).segno = (xx_segno) \
)

Definition at line 92 of file md.c.

Typedef Documentation

MdfdVec

typedef struct _MdfdVec MdfdVec

Function Documentation

_fdvec_resize()

static void _fdvec_resize ( SMgrRelation  reln, ForkNumber  forknum, int  nseg  )

static

Definition at line 1120 of file md.c.

{
    if (nseg == 0)
    {
        if (reln->md_num_open_segs[forknum] > 0)
        {
            pfree(reln->md_seg_fds[forknum]);
            reln->md_seg_fds[forknum] = NULL;
        }
    }
    else if (reln->md_num_open_segs[forknum] == 0)
    {
        reln->md_seg_fds[forknum] =
            MemoryContextAlloc(MdCxt, sizeof(MdfdVec) * nseg);
    }
    else
    {
        /*
         * It doesn't seem worthwhile complicating the code to amortize
         * repalloc() calls.  Those are far faster than PathNameOpenFile() or
         * FileClose(), and the memory context internally will sometimes avoid
         * doing an actual reallocation.
         */
        reln->md_seg_fds[forknum] =
            repalloc(reln->md_seg_fds[forknum],
                     sizeof(MdfdVec) * nseg);
    }
 
    reln->md_num_open_segs[forknum] = nseg;
}

References SMgrRelationData::md_num_open_segs, SMgrRelationData::md_seg_fds, MdCxt, MemoryContextAlloc(), pfree(), and repalloc().

Referenced by _mdfd_openseg(), mdclose(), mdcreate(), mdimmedsync(), mdopenfork(), and mdtruncate().

_mdfd_getseg()

static MdfdVec * _mdfd_getseg ( SMgrRelation  reln, ForkNumber  forknum, BlockNumber  blkno, bool  skipFsync, int  behavior  )

static

Definition at line 1226 of file md.c.

{
    MdfdVec    *v;
    BlockNumber targetseg;
    BlockNumber nextsegno;
 
    /* some way to handle non-existent segments needs to be specified */
    Assert(behavior &
           (EXTENSION_FAIL | EXTENSION_CREATE | EXTENSION_RETURN_NULL |
            EXTENSION_DONT_OPEN));
 
    targetseg = blkno / ((BlockNumber) RELSEG_SIZE);
 
    /* if an existing and opened segment, we're done */
    if (targetseg < reln->md_num_open_segs[forknum])
    {
        v = &reln->md_seg_fds[forknum][targetseg];
        return v;
    }
 
    /* The caller only wants the segment if we already had it open. */
    if (behavior & EXTENSION_DONT_OPEN)
        return NULL;
 
    /*
     * The target segment is not yet open. Iterate over all the segments
     * between the last opened and the target segment. This way missing
     * segments either raise an error, or get created (according to
     * 'behavior'). Start with either the last opened, or the first segment if
     * none was opened before.
     */
    if (reln->md_num_open_segs[forknum] > 0)
        v = &reln->md_seg_fds[forknum][reln->md_num_open_segs[forknum] - 1];
    else
    {
        v = mdopenfork(reln, forknum, behavior);
        if (!v)
            return NULL;        /* if behavior & EXTENSION_RETURN_NULL */
    }
 
    for (nextsegno = reln->md_num_open_segs[forknum];
         nextsegno <= targetseg; nextsegno++)
    {
        BlockNumber nblocks = _mdnblocks(reln, forknum, v);
        int         flags = 0;
 
        Assert(nextsegno == v->mdfd_segno + 1);
 
        if (nblocks > ((BlockNumber) RELSEG_SIZE))
            elog(FATAL, "segment too big");
 
        if ((behavior & EXTENSION_CREATE) ||
            (InRecovery && (behavior & EXTENSION_CREATE_RECOVERY)))
        {
            /*
             * Normally we will create new segments only if authorized by the
             * caller (i.e., we are doing mdextend()).  But when doing WAL
             * recovery, create segments anyway; this allows cases such as
             * replaying WAL data that has a write into a high-numbered
             * segment of a relation that was later deleted. We want to go
             * ahead and create the segments so we can finish out the replay.
             *
             * We have to maintain the invariant that segments before the last
             * active segment are of size RELSEG_SIZE; therefore, if
             * extending, pad them out with zeroes if needed.  (This only
             * matters if in recovery, or if the caller is extending the
             * relation discontiguously, but that can happen in hash indexes.)
             */
            if (nblocks < ((BlockNumber) RELSEG_SIZE))
            {
                char       *zerobuf = palloc0(BLCKSZ);
 
                mdextend(reln, forknum,
                         nextsegno * ((BlockNumber) RELSEG_SIZE) - 1,
                         zerobuf, skipFsync);
                pfree(zerobuf);
            }
            flags = O_CREAT;
        }
        else if (!(behavior & EXTENSION_DONT_CHECK_SIZE) &&
                 nblocks < ((BlockNumber) RELSEG_SIZE))
        {
            /*
             * When not extending (or explicitly including truncated
             * segments), only open the next segment if the current one is
             * exactly RELSEG_SIZE.  If not (this branch), either return NULL
             * or fail.
             */
            if (behavior & EXTENSION_RETURN_NULL)
            {
                /*
                 * Some callers discern between reasons for _mdfd_getseg()
                 * returning NULL based on errno. As there's no failing
                 * syscall involved in this case, explicitly set errno to
                 * ENOENT, as that seems the closest interpretation.
                 */
                errno = ENOENT;
                return NULL;
            }
 
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not open file \"%s\" (target block %u): previous segment is only %u blocks",
                            _mdfd_segpath(reln, forknum, nextsegno),
                            blkno, nblocks)));
        }
 
        v = _mdfd_openseg(reln, forknum, nextsegno, flags);
 
        if (v == NULL)
        {
            if ((behavior & EXTENSION_RETURN_NULL) &&
                FILE_POSSIBLY_DELETED(errno))
                return NULL;
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not open file \"%s\" (target block %u): %m",
                            _mdfd_segpath(reln, forknum, nextsegno),
                            blkno)));
        }
    }
 
    return v;
}

References _mdfd_openseg(), _mdfd_segpath(), _mdnblocks(), Assert(), elog(), ereport, errcode_for_file_access(), errmsg(), ERROR, EXTENSION_CREATE, EXTENSION_CREATE_RECOVERY, EXTENSION_DONT_CHECK_SIZE, EXTENSION_DONT_OPEN, EXTENSION_FAIL, EXTENSION_RETURN_NULL, FATAL, FILE_POSSIBLY_DELETED, InRecovery, SMgrRelationData::md_num_open_segs, SMgrRelationData::md_seg_fds, mdextend(), _MdfdVec::mdfd_segno, mdopenfork(), palloc0(), and pfree().

Referenced by mdextend(), mdprefetch(), mdread(), mdwrite(), and mdwriteback().

_mdfd_openseg()

static MdfdVec * _mdfd_openseg ( SMgrRelation  reln, ForkNumber  forknum, BlockNumber  segno, int  oflags  )

static

Definition at line 1181 of file md.c.

{
    MdfdVec    *v;
    File        fd;
    char       *fullpath;
 
    fullpath = _mdfd_segpath(reln, forknum, segno);
 
    /* open the file */
    fd = PathNameOpenFile(fullpath, O_RDWR | PG_BINARY | oflags);
 
    pfree(fullpath);
 
    if (fd < 0)
        return NULL;
 
    /*
     * Segments are always opened in order from lowest to highest, so we must
     * be adding a new one at the end.
     */
    Assert(segno == reln->md_num_open_segs[forknum]);
 
    _fdvec_resize(reln, forknum, segno + 1);
 
    /* fill the entry */
    v = &reln->md_seg_fds[forknum][segno];
    v->mdfd_vfd = fd;
    v->mdfd_segno = segno;
 
    Assert(_mdnblocks(reln, forknum, v) <= ((BlockNumber) RELSEG_SIZE));
 
    /* all done */
    return v;
}

References _fdvec_resize(), _mdfd_segpath(), _mdnblocks(), Assert(), fd(), SMgrRelationData::md_num_open_segs, SMgrRelationData::md_seg_fds, _MdfdVec::mdfd_segno, _MdfdVec::mdfd_vfd, PathNameOpenFile(), pfree(), and PG_BINARY.

Referenced by _mdfd_getseg(), mdimmedsync(), and mdnblocks().

_mdfd_segpath()

static char * _mdfd_segpath ( SMgrRelation  reln, ForkNumber  forknum, BlockNumber  segno  )

static

Definition at line 1158 of file md.c.

{
    char       *path,
               *fullpath;
 
    path = relpath(reln->smgr_rlocator, forknum);
 
    if (segno > 0)
    {
        fullpath = psprintf("%s.%u", path, segno);
        pfree(path);
    }
    else
        fullpath = path;
 
    return fullpath;
}

References pfree(), psprintf(), relpath, and SMgrRelationData::smgr_rlocator.

Referenced by _mdfd_getseg(), _mdfd_openseg(), and mdsyncfiletag().

_mdnblocks()

static BlockNumber _mdnblocks ( SMgrRelation  reln, ForkNumber  forknum, MdfdVec *  seg  )

static

Definition at line 1356 of file md.c.

{
    off_t       len;
 
    len = FileSize(seg->mdfd_vfd);
    if (len < 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not seek to end of file \"%s\": %m",
                        FilePathName(seg->mdfd_vfd))));
    /* note that this calculation will ignore any partial block at EOF */
    return (BlockNumber) (len / BLCKSZ);
}

References ereport, errcode_for_file_access(), errmsg(), ERROR, FilePathName(), FileSize(), len, and _MdfdVec::mdfd_vfd.

Referenced by _mdfd_getseg(), _mdfd_openseg(), mdextend(), mdnblocks(), and mdopenfork().

do_truncate()

static int do_truncate ( const char *  path )

static

Definition at line 312 of file md.c.

{
    int         save_errno;
    int         ret;
 
    ret = pg_truncate(path, 0);
 
    /* Log a warning here to avoid repetition in callers. */
    if (ret < 0 && errno != ENOENT)
    {
        save_errno = errno;
        ereport(WARNING,
                (errcode_for_file_access(),
                 errmsg("could not truncate file \"%s\": %m", path)));
        errno = save_errno;
    }
 
    return ret;
}

References ereport, errcode_for_file_access(), errmsg(), pg_truncate(), and WARNING.

Referenced by mdunlinkfork().

DropRelationFiles()

void DropRelationFiles	(	RelFileLocator *	delrels,
		int	ndelrels,
		bool	isRedo
	)

Definition at line 1088 of file md.c.

{
    SMgrRelation *srels;
    int         i;
 
    srels = palloc(sizeof(SMgrRelation) * ndelrels);
    for (i = 0; i < ndelrels; i++)
    {
        SMgrRelation srel = smgropen(delrels[i], InvalidBackendId);
 
        if (isRedo)
        {
            ForkNumber  fork;
 
            for (fork = 0; fork <= MAX_FORKNUM; fork++)
                XLogDropRelation(delrels[i], fork);
        }
        srels[i] = srel;
    }
 
    smgrdounlinkall(srels, ndelrels, isRedo);
 
    for (i = 0; i < ndelrels; i++)
        smgrclose(srels[i]);
    pfree(srels);
}

References i, InvalidBackendId, MAX_FORKNUM, palloc(), pfree(), smgrclose(), smgrdounlinkall(), smgropen(), and XLogDropRelation().

Referenced by FinishPreparedTransaction(), xact_redo_abort(), and xact_redo_commit().

ForgetDatabaseSyncRequests()

void ForgetDatabaseSyncRequests

(

Oid

dbid

)

Definition at line 1070 of file md.c.

{
    FileTag     tag;
    RelFileLocator rlocator;
 
    rlocator.dbOid = dbid;
    rlocator.spcOid = 0;
    rlocator.relNumber = 0;
 
    INIT_MD_FILETAG(tag, rlocator, InvalidForkNumber, InvalidBlockNumber);
 
    RegisterSyncRequest(&tag, SYNC_FILTER_REQUEST, true /* retryOnError */ );
}

References RelFileLocator::dbOid, INIT_MD_FILETAG, InvalidBlockNumber, InvalidForkNumber, RegisterSyncRequest(), RelFileLocator::relNumber, RelFileLocator::spcOid, and SYNC_FILTER_REQUEST.

Referenced by createdb_failure_callback(), dbase_redo(), and dropdb().

mdclose()

void mdclose	(	SMgrRelation	reln,
		ForkNumber	forknum
	)

Definition at line 568 of file md.c.

{
    int         nopensegs = reln->md_num_open_segs[forknum];
 
    /* No work if already closed */
    if (nopensegs == 0)
        return;
 
    /* close segments starting from the end */
    while (nopensegs > 0)
    {
        MdfdVec    *v = &reln->md_seg_fds[forknum][nopensegs - 1];
 
        FileClose(v->mdfd_vfd);
        _fdvec_resize(reln, forknum, nopensegs - 1);
        nopensegs--;
    }
}

References _fdvec_resize(), FileClose(), SMgrRelationData::md_num_open_segs, SMgrRelationData::md_seg_fds, and _MdfdVec::mdfd_vfd.

Referenced by mdexists().

mdcreate()

void mdcreate	(	SMgrRelation	reln,
		ForkNumber	forknum,
		bool	isRedo
	)

Definition at line 182 of file md.c.

{
    MdfdVec    *mdfd;
    char       *path;
    File        fd;
 
    if (isRedo && reln->md_num_open_segs[forknum] > 0)
        return;                 /* created and opened already... */
 
    Assert(reln->md_num_open_segs[forknum] == 0);
 
    /*
     * We may be using the target table space for the first time in this
     * database, so create a per-database subdirectory if needed.
     *
     * XXX this is a fairly ugly violation of module layering, but this seems
     * to be the best place to put the check.  Maybe TablespaceCreateDbspace
     * should be here and not in commands/tablespace.c?  But that would imply
     * importing a lot of stuff that smgr.c oughtn't know, either.
     */
    TablespaceCreateDbspace(reln->smgr_rlocator.locator.spcOid,
                            reln->smgr_rlocator.locator.dbOid,
                            isRedo);
 
    path = relpath(reln->smgr_rlocator, forknum);
 
    fd = PathNameOpenFile(path, O_RDWR | O_CREAT | O_EXCL | PG_BINARY);
 
    if (fd < 0)
    {
        int         save_errno = errno;
 
        if (isRedo)
            fd = PathNameOpenFile(path, O_RDWR | PG_BINARY);
        if (fd < 0)
        {
            /* be sure to report the error reported by create, not open */
            errno = save_errno;
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not create file \"%s\": %m", path)));
        }
    }
 
    pfree(path);
 
    _fdvec_resize(reln, forknum, 1);
    mdfd = &reln->md_seg_fds[forknum][0];
    mdfd->mdfd_vfd = fd;
    mdfd->mdfd_segno = 0;
}

References _fdvec_resize(), Assert(), RelFileLocator::dbOid, ereport, errcode_for_file_access(), errmsg(), ERROR, fd(), RelFileLocatorBackend::locator, SMgrRelationData::md_num_open_segs, SMgrRelationData::md_seg_fds, _MdfdVec::mdfd_segno, _MdfdVec::mdfd_vfd, PathNameOpenFile(), pfree(), PG_BINARY, relpath, SMgrRelationData::smgr_rlocator, RelFileLocator::spcOid, and TablespaceCreateDbspace().

mdexists()

bool mdexists	(	SMgrRelation	reln,
		ForkNumber	forknum
	)

Definition at line 163 of file md.c.

{
    /*
     * Close it first, to ensure that we notice if the fork has been unlinked
     * since we opened it.  As an optimization, we can skip that in recovery,
     * which already closes relations when dropping them.
     */
    if (!InRecovery)
        mdclose(reln, forknum);
 
    return (mdopenfork(reln, forknum, EXTENSION_RETURN_NULL) != NULL);
}

References EXTENSION_RETURN_NULL, InRecovery, mdclose(), and mdopenfork().

mdextend()

void mdextend	(	SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	blocknum,
		char *	buffer,
		bool	skipFsync
	)

Definition at line 449 of file md.c.

{
    off_t       seekpos;
    int         nbytes;
    MdfdVec    *v;
 
    /* This assert is too expensive to have on normally ... */
#ifdef CHECK_WRITE_VS_EXTEND
    Assert(blocknum >= mdnblocks(reln, forknum));
#endif
 
    /*
     * If a relation manages to grow to 2^32-1 blocks, refuse to extend it any
     * more --- we mustn't create a block whose number actually is
     * InvalidBlockNumber.  (Note that this failure should be unreachable
     * because of upstream checks in bufmgr.c.)
     */
    if (blocknum == InvalidBlockNumber)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("cannot extend file \"%s\" beyond %u blocks",
                        relpath(reln->smgr_rlocator, forknum),
                        InvalidBlockNumber)));
 
    v = _mdfd_getseg(reln, forknum, blocknum, skipFsync, EXTENSION_CREATE);
 
    seekpos = (off_t) BLCKSZ * (blocknum % ((BlockNumber) RELSEG_SIZE));
 
    Assert(seekpos < (off_t) BLCKSZ * RELSEG_SIZE);
 
    if ((nbytes = FileWrite(v->mdfd_vfd, buffer, BLCKSZ, seekpos, WAIT_EVENT_DATA_FILE_EXTEND)) != BLCKSZ)
    {
        if (nbytes < 0)
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not extend file \"%s\": %m",
                            FilePathName(v->mdfd_vfd)),
                     errhint("Check free disk space.")));
        /* short write: complain appropriately */
        ereport(ERROR,
                (errcode(ERRCODE_DISK_FULL),
                 errmsg("could not extend file \"%s\": wrote only %d of %d bytes at block %u",
                        FilePathName(v->mdfd_vfd),
                        nbytes, BLCKSZ, blocknum),
                 errhint("Check free disk space.")));
    }
 
    if (!skipFsync && !SmgrIsTemp(reln))
        register_dirty_segment(reln, forknum, v);
 
    Assert(_mdnblocks(reln, forknum, v) <= ((BlockNumber) RELSEG_SIZE));
}

References _mdfd_getseg(), _mdnblocks(), Assert(), ereport, errcode(), errcode_for_file_access(), errhint(), errmsg(), ERROR, EXTENSION_CREATE, FilePathName(), FileWrite(), InvalidBlockNumber, _MdfdVec::mdfd_vfd, mdnblocks(), register_dirty_segment(), relpath, SMgrRelationData::smgr_rlocator, SmgrIsTemp, and WAIT_EVENT_DATA_FILE_EXTEND.

Referenced by _mdfd_getseg().

mdfiletagmatches()

bool mdfiletagmatches	(	const FileTag *	ftag,
		const FileTag *	candidate
	)

Definition at line 1443 of file md.c.

{
    /*
     * For now we only use filter requests as a way to drop all scheduled
     * callbacks relating to a given database, when dropping the database.
     * We'll return true for all candidates that have the same database OID as
     * the ftag from the SYNC_FILTER_REQUEST request, so they're forgotten.
     */
    return ftag->rlocator.dbOid == candidate->rlocator.dbOid;
}

References RelFileLocator::dbOid, and FileTag::rlocator.

mdimmedsync()

void mdimmedsync	(	SMgrRelation	reln,
		ForkNumber	forknum
	)

Definition at line 960 of file md.c.

{
    int         segno;
    int         min_inactive_seg;
 
    /*
     * NOTE: mdnblocks makes sure we have opened all active segments, so that
     * fsync loop will get them all!
     */
    mdnblocks(reln, forknum);
 
    min_inactive_seg = segno = reln->md_num_open_segs[forknum];
 
    /*
     * Temporarily open inactive segments, then close them after sync.  There
     * may be some inactive segments left opened after fsync() error, but that
     * is harmless.  We don't bother to clean them up and take a risk of
     * further trouble.  The next mdclose() will soon close them.
     */
    while (_mdfd_openseg(reln, forknum, segno, 0) != NULL)
        segno++;
 
    while (segno > 0)
    {
        MdfdVec    *v = &reln->md_seg_fds[forknum][segno - 1];
 
        if (FileSync(v->mdfd_vfd, WAIT_EVENT_DATA_FILE_IMMEDIATE_SYNC) < 0)
            ereport(data_sync_elevel(ERROR),
                    (errcode_for_file_access(),
                     errmsg("could not fsync file \"%s\": %m",
                            FilePathName(v->mdfd_vfd))));
 
        /* Close inactive segments immediately */
        if (segno > min_inactive_seg)
        {
            FileClose(v->mdfd_vfd);
            _fdvec_resize(reln, forknum, segno - 1);
        }
 
        segno--;
    }
}

References _fdvec_resize(), _mdfd_openseg(), data_sync_elevel(), ereport, errcode_for_file_access(), errmsg(), ERROR, FileClose(), FilePathName(), FileSync(), SMgrRelationData::md_num_open_segs, SMgrRelationData::md_seg_fds, _MdfdVec::mdfd_vfd, mdnblocks(), and WAIT_EVENT_DATA_FILE_IMMEDIATE_SYNC.

mdinit()

void mdinit

(

void

)

Definition at line 150 of file md.c.

{
    MdCxt = AllocSetContextCreate(TopMemoryContext,
                                  "MdSmgr",
                                  ALLOCSET_DEFAULT_SIZES);
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, MdCxt, and TopMemoryContext.

mdnblocks()

BlockNumber mdnblocks	(	SMgrRelation	reln,
		ForkNumber	forknum
	)

Definition at line 801 of file md.c.

{
    MdfdVec    *v;
    BlockNumber nblocks;
    BlockNumber segno;
 
    mdopenfork(reln, forknum, EXTENSION_FAIL);
 
    /* mdopen has opened the first segment */
    Assert(reln->md_num_open_segs[forknum] > 0);
 
    /*
     * Start from the last open segments, to avoid redundant seeks.  We have
     * previously verified that these segments are exactly RELSEG_SIZE long,
     * and it's useless to recheck that each time.
     *
     * NOTE: this assumption could only be wrong if another backend has
     * truncated the relation.  We rely on higher code levels to handle that
     * scenario by closing and re-opening the md fd, which is handled via
     * relcache flush.  (Since the checkpointer doesn't participate in
     * relcache flush, it could have segment entries for inactive segments;
     * that's OK because the checkpointer never needs to compute relation
     * size.)
     */
    segno = reln->md_num_open_segs[forknum] - 1;
    v = &reln->md_seg_fds[forknum][segno];
 
    for (;;)
    {
        nblocks = _mdnblocks(reln, forknum, v);
        if (nblocks > ((BlockNumber) RELSEG_SIZE))
            elog(FATAL, "segment too big");
        if (nblocks < ((BlockNumber) RELSEG_SIZE))
            return (segno * ((BlockNumber) RELSEG_SIZE)) + nblocks;
 
        /*
         * If segment is exactly RELSEG_SIZE, advance to next one.
         */
        segno++;
 
        /*
         * We used to pass O_CREAT here, but that has the disadvantage that it
         * might create a segment which has vanished through some operating
         * system misadventure.  In such a case, creating the segment here
         * undermines _mdfd_getseg's attempts to notice and report an error
         * upon access to a missing segment.
         */
        v = _mdfd_openseg(reln, forknum, segno, 0);
        if (v == NULL)
            return segno * ((BlockNumber) RELSEG_SIZE);
    }
}

References _mdfd_openseg(), _mdnblocks(), Assert(), elog(), EXTENSION_FAIL, FATAL, SMgrRelationData::md_num_open_segs, SMgrRelationData::md_seg_fds, and mdopenfork().

Referenced by mdextend(), mdimmedsync(), mdtruncate(), and mdwrite().

mdopen()

void mdopen

(

SMgrRelation

reln

)

Definition at line 557 of file md.c.

{
    /* mark it not open */
    for (int forknum = 0; forknum <= MAX_FORKNUM; forknum++)
        reln->md_num_open_segs[forknum] = 0;
}

References MAX_FORKNUM, and SMgrRelationData::md_num_open_segs.

mdopenfork()

static MdfdVec * mdopenfork ( SMgrRelation  reln, ForkNumber  forknum, int  behavior  )

static

Definition at line 514 of file md.c.

{
    MdfdVec    *mdfd;
    char       *path;
    File        fd;
 
    /* No work if already open */
    if (reln->md_num_open_segs[forknum] > 0)
        return &reln->md_seg_fds[forknum][0];
 
    path = relpath(reln->smgr_rlocator, forknum);
 
    fd = PathNameOpenFile(path, O_RDWR | PG_BINARY);
 
    if (fd < 0)
    {
        if ((behavior & EXTENSION_RETURN_NULL) &&
            FILE_POSSIBLY_DELETED(errno))
        {
            pfree(path);
            return NULL;
        }
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not open file \"%s\": %m", path)));
    }
 
    pfree(path);
 
    _fdvec_resize(reln, forknum, 1);
    mdfd = &reln->md_seg_fds[forknum][0];
    mdfd->mdfd_vfd = fd;
    mdfd->mdfd_segno = 0;
 
    Assert(_mdnblocks(reln, forknum, mdfd) <= ((BlockNumber) RELSEG_SIZE));
 
    return mdfd;
}

References _fdvec_resize(), _mdnblocks(), Assert(), ereport, errcode_for_file_access(), errmsg(), ERROR, EXTENSION_RETURN_NULL, fd(), FILE_POSSIBLY_DELETED, SMgrRelationData::md_num_open_segs, SMgrRelationData::md_seg_fds, _MdfdVec::mdfd_segno, _MdfdVec::mdfd_vfd, PathNameOpenFile(), pfree(), PG_BINARY, relpath, and SMgrRelationData::smgr_rlocator.

Referenced by _mdfd_getseg(), mdexists(), and mdnblocks().

mdprefetch()

bool mdprefetch	(	SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	blocknum
	)

Definition at line 591 of file md.c.

{
#ifdef USE_PREFETCH
    off_t       seekpos;
    MdfdVec    *v;
 
    v = _mdfd_getseg(reln, forknum, blocknum, false,
                     InRecovery ? EXTENSION_RETURN_NULL : EXTENSION_FAIL);
    if (v == NULL)
        return false;
 
    seekpos = (off_t) BLCKSZ * (blocknum % ((BlockNumber) RELSEG_SIZE));
 
    Assert(seekpos < (off_t) BLCKSZ * RELSEG_SIZE);
 
    (void) FilePrefetch(v->mdfd_vfd, seekpos, BLCKSZ, WAIT_EVENT_DATA_FILE_PREFETCH);
#endif                          /* USE_PREFETCH */
 
    return true;
}

References _mdfd_getseg(), Assert(), EXTENSION_FAIL, EXTENSION_RETURN_NULL, FilePrefetch(), InRecovery, _MdfdVec::mdfd_vfd, and WAIT_EVENT_DATA_FILE_PREFETCH.

mdread()

void mdread	(	SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	blocknum,
		char *	buffer
	)

Definition at line 671 of file md.c.

{
    off_t       seekpos;
    int         nbytes;
    MdfdVec    *v;
 
    TRACE_POSTGRESQL_SMGR_MD_READ_START(forknum, blocknum,
                                        reln->smgr_rlocator.locator.spcOid,
                                        reln->smgr_rlocator.locator.dbOid,
                                        reln->smgr_rlocator.locator.relNumber,
                                        reln->smgr_rlocator.backend);
 
    v = _mdfd_getseg(reln, forknum, blocknum, false,
                     EXTENSION_FAIL | EXTENSION_CREATE_RECOVERY);
 
    seekpos = (off_t) BLCKSZ * (blocknum % ((BlockNumber) RELSEG_SIZE));
 
    Assert(seekpos < (off_t) BLCKSZ * RELSEG_SIZE);
 
    nbytes = FileRead(v->mdfd_vfd, buffer, BLCKSZ, seekpos, WAIT_EVENT_DATA_FILE_READ);
 
    TRACE_POSTGRESQL_SMGR_MD_READ_DONE(forknum, blocknum,
                                       reln->smgr_rlocator.locator.spcOid,
                                       reln->smgr_rlocator.locator.dbOid,
                                       reln->smgr_rlocator.locator.relNumber,
                                       reln->smgr_rlocator.backend,
                                       nbytes,
                                       BLCKSZ);
 
    if (nbytes != BLCKSZ)
    {
        if (nbytes < 0)
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not read block %u in file \"%s\": %m",
                            blocknum, FilePathName(v->mdfd_vfd))));
 
        /*
         * Short read: we are at or past EOF, or we read a partial block at
         * EOF.  Normally this is an error; upper levels should never try to
         * read a nonexistent block.  However, if zero_damaged_pages is ON or
         * we are InRecovery, we should instead return zeroes without
         * complaining.  This allows, for example, the case of trying to
         * update a block that was later truncated away.
         */
        if (zero_damaged_pages || InRecovery)
            MemSet(buffer, 0, BLCKSZ);
        else
            ereport(ERROR,
                    (errcode(ERRCODE_DATA_CORRUPTED),
                     errmsg("could not read block %u in file \"%s\": read only %d of %d bytes",
                            blocknum, FilePathName(v->mdfd_vfd),
                            nbytes, BLCKSZ)));
    }
}

References _mdfd_getseg(), Assert(), RelFileLocatorBackend::backend, RelFileLocator::dbOid, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errcode_for_file_access(), errmsg(), ERROR, EXTENSION_CREATE_RECOVERY, EXTENSION_FAIL, FilePathName(), FileRead(), InRecovery, RelFileLocatorBackend::locator, _MdfdVec::mdfd_vfd, MemSet, RelFileLocator::relNumber, SMgrRelationData::smgr_rlocator, RelFileLocator::spcOid, WAIT_EVENT_DATA_FILE_READ, and zero_damaged_pages.

mdsyncfiletag()

int mdsyncfiletag	(	const FileTag *	ftag,
		char *	path
	)

Definition at line 1377 of file md.c.

{
    SMgrRelation reln = smgropen(ftag->rlocator, InvalidBackendId);
    File        file;
    bool        need_to_close;
    int         result,
                save_errno;
 
    /* See if we already have the file open, or need to open it. */
    if (ftag->segno < reln->md_num_open_segs[ftag->forknum])
    {
        file = reln->md_seg_fds[ftag->forknum][ftag->segno].mdfd_vfd;
        strlcpy(path, FilePathName(file), MAXPGPATH);
        need_to_close = false;
    }
    else
    {
        char       *p;
 
        p = _mdfd_segpath(reln, ftag->forknum, ftag->segno);
        strlcpy(path, p, MAXPGPATH);
        pfree(p);
 
        file = PathNameOpenFile(path, O_RDWR | PG_BINARY);
        if (file < 0)
            return -1;
        need_to_close = true;
    }
 
    /* Sync the file. */
    result = FileSync(file, WAIT_EVENT_DATA_FILE_SYNC);
    save_errno = errno;
 
    if (need_to_close)
        FileClose(file);
 
    errno = save_errno;
    return result;
}

References _mdfd_segpath(), FileClose(), FilePathName(), FileSync(), FileTag::forknum, InvalidBackendId, MAXPGPATH, SMgrRelationData::md_num_open_segs, SMgrRelationData::md_seg_fds, _MdfdVec::mdfd_vfd, PathNameOpenFile(), pfree(), PG_BINARY, FileTag::rlocator, FileTag::segno, smgropen(), strlcpy(), and WAIT_EVENT_DATA_FILE_SYNC.

mdtruncate()

void mdtruncate	(	SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	nblocks
	)

Definition at line 858 of file md.c.

{
    BlockNumber curnblk;
    BlockNumber priorblocks;
    int         curopensegs;
 
    /*
     * NOTE: mdnblocks makes sure we have opened all active segments, so that
     * truncation loop will get them all!
     */
    curnblk = mdnblocks(reln, forknum);
    if (nblocks > curnblk)
    {
        /* Bogus request ... but no complaint if InRecovery */
        if (InRecovery)
            return;
        ereport(ERROR,
                (errmsg("could not truncate file \"%s\" to %u blocks: it's only %u blocks now",
                        relpath(reln->smgr_rlocator, forknum),
                        nblocks, curnblk)));
    }
    if (nblocks == curnblk)
        return;                 /* no work */
 
    /*
     * Truncate segments, starting at the last one. Starting at the end makes
     * managing the memory for the fd array easier, should there be errors.
     */
    curopensegs = reln->md_num_open_segs[forknum];
    while (curopensegs > 0)
    {
        MdfdVec    *v;
 
        priorblocks = (curopensegs - 1) * RELSEG_SIZE;
 
        v = &reln->md_seg_fds[forknum][curopensegs - 1];
 
        if (priorblocks > nblocks)
        {
            /*
             * This segment is no longer active. We truncate the file, but do
             * not delete it, for reasons explained in the header comments.
             */
            if (FileTruncate(v->mdfd_vfd, 0, WAIT_EVENT_DATA_FILE_TRUNCATE) < 0)
                ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not truncate file \"%s\": %m",
                                FilePathName(v->mdfd_vfd))));
 
            if (!SmgrIsTemp(reln))
                register_dirty_segment(reln, forknum, v);
 
            /* we never drop the 1st segment */
            Assert(v != &reln->md_seg_fds[forknum][0]);
 
            FileClose(v->mdfd_vfd);
            _fdvec_resize(reln, forknum, curopensegs - 1);
        }
        else if (priorblocks + ((BlockNumber) RELSEG_SIZE) > nblocks)
        {
            /*
             * This is the last segment we want to keep. Truncate the file to
             * the right length. NOTE: if nblocks is exactly a multiple K of
             * RELSEG_SIZE, we will truncate the K+1st segment to 0 length but
             * keep it. This adheres to the invariant given in the header
             * comments.
             */
            BlockNumber lastsegblocks = nblocks - priorblocks;
 
            if (FileTruncate(v->mdfd_vfd, (off_t) lastsegblocks * BLCKSZ, WAIT_EVENT_DATA_FILE_TRUNCATE) < 0)
                ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not truncate file \"%s\" to %u blocks: %m",
                                FilePathName(v->mdfd_vfd),
                                nblocks)));
            if (!SmgrIsTemp(reln))
                register_dirty_segment(reln, forknum, v);
        }
        else
        {
            /*
             * We still need this segment, so nothing to do for this and any
             * earlier segment.
             */
            break;
        }
        curopensegs--;
    }
}

References _fdvec_resize(), Assert(), ereport, errcode_for_file_access(), errmsg(), ERROR, FileClose(), FilePathName(), FileTruncate(), InRecovery, SMgrRelationData::md_num_open_segs, SMgrRelationData::md_seg_fds, _MdfdVec::mdfd_vfd, mdnblocks(), register_dirty_segment(), relpath, SMgrRelationData::smgr_rlocator, SmgrIsTemp, and WAIT_EVENT_DATA_FILE_TRUNCATE.

mdunlink()

void mdunlink	(	RelFileLocatorBackend	rlocator,
		ForkNumber	forknum,
		bool	isRedo
	)

Definition at line 296 of file md.c.

{
    /* Now do the per-fork work */
    if (forknum == InvalidForkNumber)
    {
        for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
            mdunlinkfork(rlocator, forknum, isRedo);
    }
    else
        mdunlinkfork(rlocator, forknum, isRedo);
}

References InvalidForkNumber, MAX_FORKNUM, and mdunlinkfork().

mdunlinkfiletag()

int mdunlinkfiletag	(	const FileTag *	ftag,
		char *	path
	)

Definition at line 1424 of file md.c.

{
    char       *p;
 
    /* Compute the path. */
    p = relpathperm(ftag->rlocator, MAIN_FORKNUM);
    strlcpy(path, p, MAXPGPATH);
    pfree(p);
 
    /* Try to unlink the file. */
    return unlink(path);
}

References MAIN_FORKNUM, MAXPGPATH, pfree(), relpathperm, FileTag::rlocator, and strlcpy().

mdunlinkfork()

static void mdunlinkfork ( RelFileLocatorBackend  rlocator, ForkNumber  forknum, bool  isRedo  )

static

Definition at line 333 of file md.c.

{
    char       *path;
    int         ret;
    int         save_errno;
 
    path = relpath(rlocator, forknum);
 
    /*
     * Truncate and then unlink the first segment, or just register a request
     * to unlink it later, as described in the comments for mdunlink().
     */
    if (isRedo || IsBinaryUpgrade || forknum != MAIN_FORKNUM ||
        RelFileLocatorBackendIsTemp(rlocator))
    {
        if (!RelFileLocatorBackendIsTemp(rlocator))
        {
            /* Prevent other backends' fds from holding on to the disk space */
            ret = do_truncate(path);
 
            /* Forget any pending sync requests for the first segment */
            save_errno = errno;
            register_forget_request(rlocator, forknum, 0 /* first seg */ );
            errno = save_errno;
        }
        else
            ret = 0;
 
        /* Next unlink the file, unless it was already found to be missing */
        if (ret >= 0 || errno != ENOENT)
        {
            ret = unlink(path);
            if (ret < 0 && errno != ENOENT)
            {
                save_errno = errno;
                ereport(WARNING,
                        (errcode_for_file_access(),
                         errmsg("could not remove file \"%s\": %m", path)));
                errno = save_errno;
            }
        }
    }
    else
    {
        /* Prevent other backends' fds from holding on to the disk space */
        ret = do_truncate(path);
 
        /* Register request to unlink first segment later */
        save_errno = errno;
        register_unlink_segment(rlocator, forknum, 0 /* first seg */ );
        errno = save_errno;
    }
 
    /*
     * Delete any additional segments.
     *
     * Note that because we loop until getting ENOENT, we will correctly
     * remove all inactive segments as well as active ones.  Ideally we'd
     * continue the loop until getting exactly that errno, but that risks an
     * infinite loop if the problem is directory-wide (for instance, if we
     * suddenly can't read the data directory itself).  We compromise by
     * continuing after a non-ENOENT truncate error, but stopping after any
     * unlink error.  If there is indeed a directory-wide problem, additional
     * unlink attempts wouldn't work anyway.
     */
    if (ret >= 0 || errno != ENOENT)
    {
        char       *segpath = (char *) palloc(strlen(path) + 12);
        BlockNumber segno;
 
        for (segno = 1;; segno++)
        {
            sprintf(segpath, "%s.%u", path, segno);
 
            if (!RelFileLocatorBackendIsTemp(rlocator))
            {
                /*
                 * Prevent other backends' fds from holding on to the disk
                 * space.  We're done if we see ENOENT, though.
                 */
                if (do_truncate(segpath) < 0 && errno == ENOENT)
                    break;
 
                /*
                 * Forget any pending sync requests for this segment before we
                 * try to unlink.
                 */
                register_forget_request(rlocator, forknum, segno);
            }
 
            if (unlink(segpath) < 0)
            {
                /* ENOENT is expected after the last segment... */
                if (errno != ENOENT)
                    ereport(WARNING,
                            (errcode_for_file_access(),
                             errmsg("could not remove file \"%s\": %m", segpath)));
                break;
            }
        }
        pfree(segpath);
    }
 
    pfree(path);
}

References do_truncate(), ereport, errcode_for_file_access(), errmsg(), IsBinaryUpgrade, MAIN_FORKNUM, palloc(), pfree(), register_forget_request(), register_unlink_segment(), RelFileLocatorBackendIsTemp, relpath, sprintf, and WARNING.

Referenced by mdunlink().

mdwrite()

void mdwrite	(	SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	blocknum,
		char *	buffer,
		bool	skipFsync
	)

Definition at line 736 of file md.c.

{
    off_t       seekpos;
    int         nbytes;
    MdfdVec    *v;
 
    /* This assert is too expensive to have on normally ... */
#ifdef CHECK_WRITE_VS_EXTEND
    Assert(blocknum < mdnblocks(reln, forknum));
#endif
 
    TRACE_POSTGRESQL_SMGR_MD_WRITE_START(forknum, blocknum,
                                         reln->smgr_rlocator.locator.spcOid,
                                         reln->smgr_rlocator.locator.dbOid,
                                         reln->smgr_rlocator.locator.relNumber,
                                         reln->smgr_rlocator.backend);
 
    v = _mdfd_getseg(reln, forknum, blocknum, skipFsync,
                     EXTENSION_FAIL | EXTENSION_CREATE_RECOVERY);
 
    seekpos = (off_t) BLCKSZ * (blocknum % ((BlockNumber) RELSEG_SIZE));
 
    Assert(seekpos < (off_t) BLCKSZ * RELSEG_SIZE);
 
    nbytes = FileWrite(v->mdfd_vfd, buffer, BLCKSZ, seekpos, WAIT_EVENT_DATA_FILE_WRITE);
 
    TRACE_POSTGRESQL_SMGR_MD_WRITE_DONE(forknum, blocknum,
                                        reln->smgr_rlocator.locator.spcOid,
                                        reln->smgr_rlocator.locator.dbOid,
                                        reln->smgr_rlocator.locator.relNumber,
                                        reln->smgr_rlocator.backend,
                                        nbytes,
                                        BLCKSZ);
 
    if (nbytes != BLCKSZ)
    {
        if (nbytes < 0)
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not write block %u in file \"%s\": %m",
                            blocknum, FilePathName(v->mdfd_vfd))));
        /* short write: complain appropriately */
        ereport(ERROR,
                (errcode(ERRCODE_DISK_FULL),
                 errmsg("could not write block %u in file \"%s\": wrote only %d of %d bytes",
                        blocknum,
                        FilePathName(v->mdfd_vfd),
                        nbytes, BLCKSZ),
                 errhint("Check free disk space.")));
    }
 
    if (!skipFsync && !SmgrIsTemp(reln))
        register_dirty_segment(reln, forknum, v);
}

References _mdfd_getseg(), Assert(), RelFileLocatorBackend::backend, RelFileLocator::dbOid, ereport, errcode(), errcode_for_file_access(), errhint(), errmsg(), ERROR, EXTENSION_CREATE_RECOVERY, EXTENSION_FAIL, FilePathName(), FileWrite(), RelFileLocatorBackend::locator, _MdfdVec::mdfd_vfd, mdnblocks(), register_dirty_segment(), RelFileLocator::relNumber, SMgrRelationData::smgr_rlocator, SmgrIsTemp, RelFileLocator::spcOid, and WAIT_EVENT_DATA_FILE_WRITE.

mdwriteback()

void mdwriteback	(	SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	blocknum,
		BlockNumber	nblocks
	)

Definition at line 619 of file md.c.

{
    /*
     * Issue flush requests in as few requests as possible; have to split at
     * segment boundaries though, since those are actually separate files.
     */
    while (nblocks > 0)
    {
        BlockNumber nflush = nblocks;
        off_t       seekpos;
        MdfdVec    *v;
        int         segnum_start,
                    segnum_end;
 
        v = _mdfd_getseg(reln, forknum, blocknum, true /* not used */ ,
                         EXTENSION_DONT_OPEN);
 
        /*
         * We might be flushing buffers of already removed relations, that's
         * ok, just ignore that case.  If the segment file wasn't open already
         * (ie from a recent mdwrite()), then we don't want to re-open it, to
         * avoid a race with PROCSIGNAL_BARRIER_SMGRRELEASE that might leave
         * us with a descriptor to a file that is about to be unlinked.
         */
        if (!v)
            return;
 
        /* compute offset inside the current segment */
        segnum_start = blocknum / RELSEG_SIZE;
 
        /* compute number of desired writes within the current segment */
        segnum_end = (blocknum + nblocks - 1) / RELSEG_SIZE;
        if (segnum_start != segnum_end)
            nflush = RELSEG_SIZE - (blocknum % ((BlockNumber) RELSEG_SIZE));
 
        Assert(nflush >= 1);
        Assert(nflush <= nblocks);
 
        seekpos = (off_t) BLCKSZ * (blocknum % ((BlockNumber) RELSEG_SIZE));
 
        FileWriteback(v->mdfd_vfd, seekpos, (off_t) BLCKSZ * nflush, WAIT_EVENT_DATA_FILE_FLUSH);
 
        nblocks -= nflush;
        blocknum += nflush;
    }
}

References _mdfd_getseg(), Assert(), EXTENSION_DONT_OPEN, FileWriteback(), _MdfdVec::mdfd_vfd, and WAIT_EVENT_DATA_FILE_FLUSH.

register_dirty_segment()

static void register_dirty_segment ( SMgrRelation  reln, ForkNumber  forknum, MdfdVec *  seg  )

static

Definition at line 1013 of file md.c.

{
    FileTag     tag;
 
    INIT_MD_FILETAG(tag, reln->smgr_rlocator.locator, forknum, seg->mdfd_segno);
 
    /* Temp relations should never be fsync'd */
    Assert(!SmgrIsTemp(reln));
 
    if (!RegisterSyncRequest(&tag, SYNC_REQUEST, false /* retryOnError */ ))
    {
        ereport(DEBUG1,
                (errmsg_internal("could not forward fsync request because request queue is full")));
 
        if (FileSync(seg->mdfd_vfd, WAIT_EVENT_DATA_FILE_SYNC) < 0)
            ereport(data_sync_elevel(ERROR),
                    (errcode_for_file_access(),
                     errmsg("could not fsync file \"%s\": %m",
                            FilePathName(seg->mdfd_vfd))));
    }
}

References Assert(), data_sync_elevel(), DEBUG1, ereport, errcode_for_file_access(), errmsg(), errmsg_internal(), ERROR, FilePathName(), FileSync(), INIT_MD_FILETAG, RelFileLocatorBackend::locator, _MdfdVec::mdfd_segno, _MdfdVec::mdfd_vfd, RegisterSyncRequest(), SMgrRelationData::smgr_rlocator, SmgrIsTemp, SYNC_REQUEST, and WAIT_EVENT_DATA_FILE_SYNC.

Referenced by mdextend(), mdtruncate(), and mdwrite().

register_forget_request()

static void register_forget_request ( RelFileLocatorBackend  rlocator, ForkNumber  forknum, BlockNumber  segno  )

static

Definition at line 1056 of file md.c.

{
    FileTag     tag;
 
    INIT_MD_FILETAG(tag, rlocator.locator, forknum, segno);
 
    RegisterSyncRequest(&tag, SYNC_FORGET_REQUEST, true /* retryOnError */ );
}

References INIT_MD_FILETAG, RelFileLocatorBackend::locator, RegisterSyncRequest(), and SYNC_FORGET_REQUEST.

Referenced by mdunlinkfork().

register_unlink_segment()

static void register_unlink_segment ( RelFileLocatorBackend  rlocator, ForkNumber  forknum, BlockNumber  segno  )

static

Definition at line 1039 of file md.c.

{
    FileTag     tag;
 
    INIT_MD_FILETAG(tag, rlocator.locator, forknum, segno);
 
    /* Should never be used with temp relations */
    Assert(!RelFileLocatorBackendIsTemp(rlocator));
 
    RegisterSyncRequest(&tag, SYNC_UNLINK_REQUEST, true /* retryOnError */ );
}

References Assert(), INIT_MD_FILETAG, RelFileLocatorBackend::locator, RegisterSyncRequest(), RelFileLocatorBackendIsTemp, and SYNC_UNLINK_REQUEST.

Referenced by mdunlinkfork().

Variable Documentation

MdCxt

MemoryContext MdCxt

static

Definition at line 88 of file md.c.

Referenced by _fdvec_resize(), and mdinit().