md.h File Reference

#include "storage/aio_types.h"
#include "storage/block.h"
#include "storage/relfilelocator.h"
#include "storage/smgr.h"
#include "storage/sync.h"

Include dependency graph for md.h:

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

Go to the source code of this file.

Functions
void	mdinit (void)
void	mdopen (SMgrRelation reln)
void	mdclose (SMgrRelation reln, ForkNumber forknum)
void	mdcreate (SMgrRelation reln, ForkNumber forknum, bool isRedo)
bool	mdexists (SMgrRelation reln, ForkNumber forknum)
void	mdunlink (RelFileLocatorBackend rlocator, ForkNumber forknum, bool isRedo)
void	mdextend (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, const void *buffer, bool skipFsync)
void	mdzeroextend (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, int nblocks, bool skipFsync)
bool	mdprefetch (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, int nblocks)
uint32	mdmaxcombine (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum)
void	mdreadv (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, void **buffers, BlockNumber nblocks)
void	mdstartreadv (PgAioHandle *ioh, SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, void **buffers, BlockNumber nblocks)
void	mdwritev (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, const void **buffers, BlockNumber nblocks, bool skipFsync)
void	mdwriteback (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, BlockNumber nblocks)
BlockNumber	mdnblocks (SMgrRelation reln, ForkNumber forknum)
void	mdtruncate (SMgrRelation reln, ForkNumber forknum, BlockNumber curnblk, BlockNumber nblocks)
void	mdimmedsync (SMgrRelation reln, ForkNumber forknum)
void	mdregistersync (SMgrRelation reln, ForkNumber forknum)
int	mdfd (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, uint32 *off)
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
PGDLLIMPORT const PgAioHandleCallbacks	aio_md_readv_cb

Function Documentation

DropRelationFiles()

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

Definition at line 1587 of file md.c.

{
    SMgrRelation *srels;
    int         i;
 
    srels = palloc(sizeof(SMgrRelation) * ndelrels);
    for (i = 0; i < ndelrels; i++)
    {
        SMgrRelation srel = smgropen(delrels[i], INVALID_PROC_NUMBER);
 
        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, INVALID_PROC_NUMBER, 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 1569 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 703 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 212 of file md.c.

{
    MdfdVec    *mdfd;
    RelPathStr  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.str, _mdfd_open_flags() | O_CREAT | O_EXCL);
 
    if (fd < 0)
    {
        int         save_errno = errno;
 
        if (isRedo)
            fd = PathNameOpenFile(path.str, _mdfd_open_flags());
        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.str)));
        }
    }
 
    _fdvec_resize(reln, forknum, 1);
    mdfd = &reln->md_seg_fds[forknum][0];
    mdfd->mdfd_vfd = fd;
    mdfd->mdfd_segno = 0;
 
    if (!SmgrIsTemp(reln))
        register_dirty_segment(reln, forknum, mdfd);
}

References _fdvec_resize(), _mdfd_open_flags(), Assert(), RelFileLocator::dbOid, ereport, errcode_for_file_access(), errmsg(), ERROR, fd(), RelFileLocatorBackend::locator, SMgrRelationData::md_num_open_segs, SMgrRelationData::md_seg_fds, mdfd(), PathNameOpenFile(), register_dirty_segment(), relpath, SMgrRelationData::smgr_rlocator, SmgrIsTemp, RelFileLocator::spcOid, RelPathStr::str, and TablespaceCreateDbspace().

mdexists()

bool mdexists	(	SMgrRelation	reln,
		ForkNumber	forknum
	)

Definition at line 193 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,
		const void *	buffer,
		bool	skipFsync
	)

Definition at line 477 of file md.c.

{
    off_t       seekpos;
    int         nbytes;
    MdfdVec    *v;
 
    /* If this build supports direct I/O, the buffer must be I/O aligned. */
    if (PG_O_DIRECT != 0 && PG_IO_ALIGN_SIZE <= BLCKSZ)
        Assert((uintptr_t) buffer == TYPEALIGN(PG_IO_ALIGN_SIZE, buffer));
 
    /* 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).str,
                        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(), PG_IO_ALIGN_SIZE, PG_O_DIRECT, register_dirty_segment(), relpath, SMgrRelationData::smgr_rlocator, SmgrIsTemp, and TYPEALIGN.

Referenced by _mdfd_getseg().

mdfd()

int mdfd	(	SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	blocknum,
		uint32 *	off
	)

Definition at line 1470 of file md.c.

{
    MdfdVec    *v = mdopenfork(reln, forknum, EXTENSION_FAIL);
 
    v = _mdfd_getseg(reln, forknum, blocknum, false,
                     EXTENSION_FAIL);
 
    *off = (off_t) BLCKSZ * (blocknum % ((BlockNumber) RELSEG_SIZE));
 
    Assert(*off < (off_t) BLCKSZ * RELSEG_SIZE);
 
    return FileGetRawDesc(v->mdfd_vfd);
}

References _mdfd_getseg(), Assert(), EXTENSION_FAIL, FileGetRawDesc(), _MdfdVec::mdfd_vfd, and mdopenfork().

Referenced by mdcreate(), and mdopenfork().

mdfiletagmatches()

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

Definition at line 1950 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 1417 of file md.c.

{
    int         segno;
    int         min_inactive_seg;
 
    /*
     * NOTE: mdnblocks makes sure we have opened all active segments, so that
     * the loop below 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];
 
        /*
         * fsyncs done through mdimmedsync() should be tracked in a separate
         * IOContext than those done through mdsyncfiletag() to differentiate
         * between unavoidable client backend fsyncs (e.g. those done during
         * index build) and those which ideally would have been done by the
         * checkpointer. Since other IO operations bypassing the buffer
         * manager could also be tracked in such an IOContext, wait until
         * these are also tracked to track immediate fsyncs.
         */
        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, and mdnblocks().

mdinit()

void mdinit

(

void

)

Definition at line 180 of file md.c.

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

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, MdCxt, and TopMemoryContext.

mdmaxcombine()

uint32 mdmaxcombine	(	SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	blocknum
	)

Definition at line 823 of file md.c.

{
    BlockNumber segoff;
 
    segoff = blocknum % ((BlockNumber) RELSEG_SIZE);
 
    return RELSEG_SIZE - segoff;
}

mdnblocks()

BlockNumber mdnblocks	(	SMgrRelation	reln,
		ForkNumber	forknum
	)

Definition at line 1213 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(), mdregistersync(), mdwritev(), and mdzeroextend().

mdopen()

void mdopen

(

SMgrRelation

reln

)

Definition at line 692 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.

mdprefetch()

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

Definition at line 726 of file md.c.

{
#ifdef USE_PREFETCH
 
    Assert((io_direct_flags & IO_DIRECT_DATA) == 0);
 
    if ((uint64) blocknum + nblocks > (uint64) MaxBlockNumber + 1)
        return false;
 
    while (nblocks > 0)
    {
        off_t       seekpos;
        MdfdVec    *v;
        int         nblocks_this_segment;
 
        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);
 
        nblocks_this_segment =
            Min(nblocks,
                RELSEG_SIZE - (blocknum % ((BlockNumber) RELSEG_SIZE)));
 
        (void) FilePrefetch(v->mdfd_vfd, seekpos, BLCKSZ * nblocks_this_segment,
                            WAIT_EVENT_DATA_FILE_PREFETCH);
 
        blocknum += nblocks_this_segment;
        nblocks -= nblocks_this_segment;
    }
#endif                          /* USE_PREFETCH */
 
    return true;
}

References _mdfd_getseg(), Assert(), EXTENSION_FAIL, EXTENSION_RETURN_NULL, FilePrefetch(), InRecovery, IO_DIRECT_DATA, io_direct_flags, MaxBlockNumber, _MdfdVec::mdfd_vfd, and Min.

mdreadv()

void mdreadv	(	SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	blocknum,
		void **	buffers,
		BlockNumber	nblocks
	)

Definition at line 837 of file md.c.

{
    while (nblocks > 0)
    {
        struct iovec iov[PG_IOV_MAX];
        int         iovcnt;
        off_t       seekpos;
        int         nbytes;
        MdfdVec    *v;
        BlockNumber nblocks_this_segment;
        size_t      transferred_this_segment;
        size_t      size_this_segment;
 
        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);
 
        nblocks_this_segment =
            Min(nblocks,
                RELSEG_SIZE - (blocknum % ((BlockNumber) RELSEG_SIZE)));
        nblocks_this_segment = Min(nblocks_this_segment, lengthof(iov));
 
        if (nblocks_this_segment != nblocks)
            elog(ERROR, "read crosses segment boundary");
 
        iovcnt = buffers_to_iovec(iov, buffers, nblocks_this_segment);
        size_this_segment = nblocks_this_segment * BLCKSZ;
        transferred_this_segment = 0;
 
        /*
         * Inner loop to continue after a short read.  We'll keep going until
         * we hit EOF rather than assuming that a short read means we hit the
         * end.
         */
        for (;;)
        {
            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);
            nbytes = FileReadV(v->mdfd_vfd, iov, iovcnt, 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,
                                               size_this_segment - transferred_this_segment);
 
#ifdef SIMULATE_SHORT_READ
            nbytes = Min(nbytes, 4096);
#endif
 
            if (nbytes < 0)
                ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not read blocks %u..%u in file \"%s\": %m",
                                blocknum,
                                blocknum + nblocks_this_segment - 1,
                                FilePathName(v->mdfd_vfd))));
 
            if (nbytes == 0)
            {
                /*
                 * 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.
                 *
                 * NB: We think that this codepath is unreachable in recovery
                 * and incomplete with zero_damaged_pages, as missing segments
                 * are not created. Putting blocks into the buffer-pool that
                 * do not exist on disk is rather problematic, as it will not
                 * be found by scans that rely on smgrnblocks(), as they are
                 * beyond EOF. It also can cause weird problems with relation
                 * extension, as relation extension does not expect blocks
                 * beyond EOF to exist.
                 *
                 * Therefore we do not want to copy the logic into
                 * mdstartreadv(), where it would have to be more complicated
                 * due to potential differences in the zero_damaged_pages
                 * setting between the definer and completor of IO.
                 *
                 * For PG 18, we are putting an Assert(false) in mdreadv()
                 * (triggering failures in assertion-enabled builds, but
                 * continuing to work in production builds). Afterwards we
                 * plan to remove this code entirely.
                 */
                if (zero_damaged_pages || InRecovery)
                {
                    Assert(false);  /* see comment above */
 
                    for (BlockNumber i = transferred_this_segment / BLCKSZ;
                         i < nblocks_this_segment;
                         ++i)
                        memset(buffers[i], 0, BLCKSZ);
                    break;
                }
                else
                    ereport(ERROR,
                            (errcode(ERRCODE_DATA_CORRUPTED),
                             errmsg("could not read blocks %u..%u in file \"%s\": read only %zu of %zu bytes",
                                    blocknum,
                                    blocknum + nblocks_this_segment - 1,
                                    FilePathName(v->mdfd_vfd),
                                    transferred_this_segment,
                                    size_this_segment)));
            }
 
            /* One loop should usually be enough. */
            transferred_this_segment += nbytes;
            Assert(transferred_this_segment <= size_this_segment);
            if (transferred_this_segment == size_this_segment)
                break;
 
            /* Adjust position and vectors after a short read. */
            seekpos += nbytes;
            iovcnt = compute_remaining_iovec(iov, iov, iovcnt, nbytes);
        }
 
        nblocks -= nblocks_this_segment;
        buffers += nblocks_this_segment;
        blocknum += nblocks_this_segment;
    }
}

References _mdfd_getseg(), Assert(), RelFileLocatorBackend::backend, buffers_to_iovec(), compute_remaining_iovec(), RelFileLocator::dbOid, elog, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errcode_for_file_access(), errmsg(), ERROR, EXTENSION_CREATE_RECOVERY, EXTENSION_FAIL, FilePathName(), FileReadV(), i, InRecovery, lengthof, RelFileLocatorBackend::locator, _MdfdVec::mdfd_vfd, Min, PG_IOV_MAX, RelFileLocator::relNumber, SMgrRelationData::smgr_rlocator, RelFileLocator::spcOid, and zero_damaged_pages.

mdregistersync()

void mdregistersync	(	SMgrRelation	reln,
		ForkNumber	forknum
	)

Definition at line 1366 of file md.c.

{
    int         segno;
    int         min_inactive_seg;
 
    /*
     * NOTE: mdnblocks makes sure we have opened all active segments, so that
     * the loop below 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 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];
 
        register_dirty_segment(reln, forknum, v);
 
        /* 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(), FileClose(), SMgrRelationData::md_num_open_segs, SMgrRelationData::md_seg_fds, _MdfdVec::mdfd_vfd, mdnblocks(), and register_dirty_segment().

mdstartreadv()

void mdstartreadv	(	PgAioHandle *	ioh,
		SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	blocknum,
		void **	buffers,
		BlockNumber	nblocks
	)

Definition at line 975 of file md.c.

{
    off_t       seekpos;
    MdfdVec    *v;
    BlockNumber nblocks_this_segment;
    struct iovec *iov;
    int         iovcnt;
    int         ret;
 
    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);
 
    nblocks_this_segment =
        Min(nblocks,
            RELSEG_SIZE - (blocknum % ((BlockNumber) RELSEG_SIZE)));
 
    if (nblocks_this_segment != nblocks)
        elog(ERROR, "read crossing segment boundary");
 
    iovcnt = pgaio_io_get_iovec(ioh, &iov);
 
    Assert(nblocks <= iovcnt);
 
    iovcnt = buffers_to_iovec(iov, buffers, nblocks_this_segment);
 
    Assert(iovcnt <= nblocks_this_segment);
 
    if (!(io_direct_flags & IO_DIRECT_DATA))
        pgaio_io_set_flag(ioh, PGAIO_HF_BUFFERED);
 
    pgaio_io_set_target_smgr(ioh,
                             reln,
                             forknum,
                             blocknum,
                             nblocks,
                             false);
    pgaio_io_register_callbacks(ioh, PGAIO_HCB_MD_READV, 0);
 
    ret = FileStartReadV(ioh, v->mdfd_vfd, iovcnt, seekpos, WAIT_EVENT_DATA_FILE_READ);
    if (ret != 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not start reading blocks %u..%u in file \"%s\": %m",
                        blocknum,
                        blocknum + nblocks_this_segment - 1,
                        FilePathName(v->mdfd_vfd))));
 
    /*
     * The error checks corresponding to the post-read checks in mdreadv() are
     * in md_readv_complete().
     *
     * However we chose, at least for now, to not implement the
     * zero_damaged_pages logic present in mdreadv(). As outlined in mdreadv()
     * that logic is rather problematic, and we want to get rid of it. Here
     * equivalent logic would have to be more complicated due to potential
     * differences in the zero_damaged_pages setting between the definer and
     * completor of IO.
     */
}

References _mdfd_getseg(), Assert(), buffers_to_iovec(), elog, ereport, errcode_for_file_access(), errmsg(), ERROR, EXTENSION_CREATE_RECOVERY, EXTENSION_FAIL, FilePathName(), FileStartReadV(), IO_DIRECT_DATA, io_direct_flags, _MdfdVec::mdfd_vfd, Min, PGAIO_HCB_MD_READV, PGAIO_HF_BUFFERED, pgaio_io_get_iovec(), pgaio_io_register_callbacks(), pgaio_io_set_flag(), and pgaio_io_set_target_smgr().

mdsyncfiletag()

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

Definition at line 1880 of file md.c.

{
    SMgrRelation reln = smgropen(ftag->rlocator, INVALID_PROC_NUMBER);
    File        file;
    instr_time  io_start;
    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
    {
        MdPathStr   p;
 
        p = _mdfd_segpath(reln, ftag->forknum, ftag->segno);
        strlcpy(path, p.str, MD_PATH_STR_MAXLEN);
 
        file = PathNameOpenFile(path, _mdfd_open_flags());
        if (file < 0)
            return -1;
        need_to_close = true;
    }
 
    io_start = pgstat_prepare_io_time(track_io_timing);
 
    /* Sync the file. */
    result = FileSync(file, WAIT_EVENT_DATA_FILE_SYNC);
    save_errno = errno;
 
    if (need_to_close)
        FileClose(file);
 
    pgstat_count_io_op_time(IOOBJECT_RELATION, IOCONTEXT_NORMAL,
                            IOOP_FSYNC, io_start, 1, 0);
 
    errno = save_errno;
    return result;
}

References _mdfd_open_flags(), _mdfd_segpath(), FileClose(), FilePathName(), FileSync(), FileTag::forknum, INVALID_PROC_NUMBER, IOCONTEXT_NORMAL, IOOBJECT_RELATION, IOOP_FSYNC, MAXPGPATH, SMgrRelationData::md_num_open_segs, MD_PATH_STR_MAXLEN, SMgrRelationData::md_seg_fds, _MdfdVec::mdfd_vfd, PathNameOpenFile(), pgstat_count_io_op_time(), pgstat_prepare_io_time(), FileTag::rlocator, FileTag::segno, smgropen(), MdPathStr::str, strlcpy(), and track_io_timing.

mdtruncate()

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

Definition at line 1277 of file md.c.

{
    BlockNumber priorblocks;
    int         curopensegs;
 
    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).str,
                        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, register_dirty_segment(), relpath, SMgrRelationData::smgr_rlocator, and SmgrIsTemp.

mdunlink()

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

Definition at line 327 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 1932 of file md.c.

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

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

mdwriteback()

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

Definition at line 1154 of file md.c.

{
    Assert((io_direct_flags & IO_DIRECT_DATA) == 0);
 
    /*
     * 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(), IO_DIRECT_DATA, io_direct_flags, and _MdfdVec::mdfd_vfd.

mdwritev()

void mdwritev	(	SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	blocknum,
		const void **	buffers,
		BlockNumber	nblocks,
		bool	skipFsync
	)

Definition at line 1049 of file md.c.

{
    /* This assert is too expensive to have on normally ... */
#ifdef CHECK_WRITE_VS_EXTEND
    Assert((uint64) blocknum + (uint64) nblocks <= (uint64) mdnblocks(reln, forknum));
#endif
 
    while (nblocks > 0)
    {
        struct iovec iov[PG_IOV_MAX];
        int         iovcnt;
        off_t       seekpos;
        int         nbytes;
        MdfdVec    *v;
        BlockNumber nblocks_this_segment;
        size_t      transferred_this_segment;
        size_t      size_this_segment;
 
        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);
 
        nblocks_this_segment =
            Min(nblocks,
                RELSEG_SIZE - (blocknum % ((BlockNumber) RELSEG_SIZE)));
        nblocks_this_segment = Min(nblocks_this_segment, lengthof(iov));
 
        if (nblocks_this_segment != nblocks)
            elog(ERROR, "write crosses segment boundary");
 
        iovcnt = buffers_to_iovec(iov, (void **) buffers, nblocks_this_segment);
        size_this_segment = nblocks_this_segment * BLCKSZ;
        transferred_this_segment = 0;
 
        /*
         * Inner loop to continue after a short write.  If the reason is that
         * we're out of disk space, a future attempt should get an ENOSPC
         * error from the kernel.
         */
        for (;;)
        {
            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);
            nbytes = FileWriteV(v->mdfd_vfd, iov, iovcnt, 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,
                                                size_this_segment - transferred_this_segment);
 
#ifdef SIMULATE_SHORT_WRITE
            nbytes = Min(nbytes, 4096);
#endif
 
            if (nbytes < 0)
            {
                bool        enospc = errno == ENOSPC;
 
                ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not write blocks %u..%u in file \"%s\": %m",
                                blocknum,
                                blocknum + nblocks_this_segment - 1,
                                FilePathName(v->mdfd_vfd)),
                         enospc ? errhint("Check free disk space.") : 0));
            }
 
            /* One loop should usually be enough. */
            transferred_this_segment += nbytes;
            Assert(transferred_this_segment <= size_this_segment);
            if (transferred_this_segment == size_this_segment)
                break;
 
            /* Adjust position and iovecs after a short write. */
            seekpos += nbytes;
            iovcnt = compute_remaining_iovec(iov, iov, iovcnt, nbytes);
        }
 
        if (!skipFsync && !SmgrIsTemp(reln))
            register_dirty_segment(reln, forknum, v);
 
        nblocks -= nblocks_this_segment;
        buffers += nblocks_this_segment;
        blocknum += nblocks_this_segment;
    }
}

References _mdfd_getseg(), Assert(), RelFileLocatorBackend::backend, buffers_to_iovec(), compute_remaining_iovec(), RelFileLocator::dbOid, elog, ereport, errcode_for_file_access(), errhint(), errmsg(), ERROR, EXTENSION_CREATE_RECOVERY, EXTENSION_FAIL, FilePathName(), FileWriteV(), lengthof, RelFileLocatorBackend::locator, _MdfdVec::mdfd_vfd, mdnblocks(), Min, PG_IOV_MAX, register_dirty_segment(), RelFileLocator::relNumber, SMgrRelationData::smgr_rlocator, SmgrIsTemp, and RelFileLocator::spcOid.

mdzeroextend()

void mdzeroextend	(	SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	blocknum,
		int	nblocks,
		bool	skipFsync
	)

Definition at line 542 of file md.c.

{
    MdfdVec    *v;
    BlockNumber curblocknum = blocknum;
    int         remblocks = nblocks;
 
    Assert(nblocks > 0);
 
    /* 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 or larger.
     */
    if ((uint64) blocknum + nblocks >= (uint64) InvalidBlockNumber)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("cannot extend file \"%s\" beyond %u blocks",
                        relpath(reln->smgr_rlocator, forknum).str,
                        InvalidBlockNumber)));
 
    while (remblocks > 0)
    {
        BlockNumber segstartblock = curblocknum % ((BlockNumber) RELSEG_SIZE);
        off_t       seekpos = (off_t) BLCKSZ * segstartblock;
        int         numblocks;
 
        if (segstartblock + remblocks > RELSEG_SIZE)
            numblocks = RELSEG_SIZE - segstartblock;
        else
            numblocks = remblocks;
 
        v = _mdfd_getseg(reln, forknum, curblocknum, skipFsync, EXTENSION_CREATE);
 
        Assert(segstartblock < RELSEG_SIZE);
        Assert(segstartblock + numblocks <= RELSEG_SIZE);
 
        /*
         * If available and useful, use posix_fallocate() (via
         * FileFallocate()) to extend the relation. That's often more
         * efficient than using write(), as it commonly won't cause the kernel
         * to allocate page cache space for the extended pages.
         *
         * However, we don't use FileFallocate() for small extensions, as it
         * defeats delayed allocation on some filesystems. Not clear where
         * that decision should be made though? For now just use a cutoff of
         * 8, anything between 4 and 8 worked OK in some local testing.
         */
        if (numblocks > 8)
        {
            int         ret;
 
            ret = FileFallocate(v->mdfd_vfd,
                                seekpos, (off_t) BLCKSZ * numblocks,
                                WAIT_EVENT_DATA_FILE_EXTEND);
            if (ret != 0)
            {
                ereport(ERROR,
                        errcode_for_file_access(),
                        errmsg("could not extend file \"%s\" with FileFallocate(): %m",
                               FilePathName(v->mdfd_vfd)),
                        errhint("Check free disk space."));
            }
        }
        else
        {
            int         ret;
 
            /*
             * Even if we don't want to use fallocate, we can still extend a
             * bit more efficiently than writing each 8kB block individually.
             * pg_pwrite_zeros() (via FileZero()) uses pg_pwritev_with_retry()
             * to avoid multiple writes or needing a zeroed buffer for the
             * whole length of the extension.
             */
            ret = FileZero(v->mdfd_vfd,
                           seekpos, (off_t) BLCKSZ * numblocks,
                           WAIT_EVENT_DATA_FILE_EXTEND);
            if (ret < 0)
                ereport(ERROR,
                        errcode_for_file_access(),
                        errmsg("could not extend file \"%s\": %m",
                               FilePathName(v->mdfd_vfd)),
                        errhint("Check free disk space."));
        }
 
        if (!skipFsync && !SmgrIsTemp(reln))
            register_dirty_segment(reln, forknum, v);
 
        Assert(_mdnblocks(reln, forknum, v) <= ((BlockNumber) RELSEG_SIZE));
 
        remblocks -= numblocks;
        curblocknum += numblocks;
    }
}

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

Variable Documentation

aio_md_readv_cb

PGDLLIMPORT const PgAioHandleCallbacks aio_md_readv_cb

extern

Definition at line 159 of file md.c.