multixact_read_v18.c File Reference

#include "postgres_fe.h"
#include "multixact_read_v18.h"
#include "pg_upgrade.h"

Include dependency graph for multixact_read_v18.c:

Go to the source code of this file.

Macros
#define	MultiXactOffset   should_not_be_used
#define	MULTIXACT_OFFSETS_PER_PAGE   (BLCKSZ / sizeof(MultiXactOffset32))
#define	MXACT_MEMBER_BITS_PER_XACT   8
#define	MXACT_MEMBER_FLAGS_PER_BYTE   1
#define	MXACT_MEMBER_XACT_BITMASK   ((1 << MXACT_MEMBER_BITS_PER_XACT) - 1)
#define	MULTIXACT_FLAGBYTES_PER_GROUP   4
#define	MULTIXACT_MEMBERS_PER_MEMBERGROUP    (MULTIXACT_FLAGBYTES_PER_GROUP * MXACT_MEMBER_FLAGS_PER_BYTE)
#define	MULTIXACT_MEMBERGROUP_SIZE    (sizeof(TransactionId) * MULTIXACT_MEMBERS_PER_MEMBERGROUP + MULTIXACT_FLAGBYTES_PER_GROUP)
#define	MULTIXACT_MEMBERGROUPS_PER_PAGE   (BLCKSZ / MULTIXACT_MEMBERGROUP_SIZE)
#define	MULTIXACT_MEMBERS_PER_PAGE    (MULTIXACT_MEMBERGROUPS_PER_PAGE * MULTIXACT_MEMBERS_PER_MEMBERGROUP)

Functions
static int64	MultiXactIdToOffsetPage (MultiXactId multi)
static int	MultiXactIdToOffsetEntry (MultiXactId multi)
static int64	MXOffsetToMemberPage (MultiXactOffset32 offset)
static int	MXOffsetToFlagsOffset (MultiXactOffset32 offset)
static int	MXOffsetToMemberOffset (MultiXactOffset32 offset)
static int	MXOffsetToFlagsBitShift (MultiXactOffset32 offset)
OldMultiXactReader *	AllocOldMultiXactRead (char *pgdata, MultiXactId nextMulti, MultiXactOffset32 nextOffset)
bool	GetOldMultiXactIdSingleMember (OldMultiXactReader *state, MultiXactId multi, MultiXactMember *member)
void	FreeOldMultiXactReader (OldMultiXactReader *state)

Macro Definition Documentation

MULTIXACT_FLAGBYTES_PER_GROUP

#define MULTIXACT_FLAGBYTES_PER_GROUP   4

Definition at line 65 of file multixact_read_v18.c.

MULTIXACT_MEMBERGROUP_SIZE

#define MULTIXACT_MEMBERGROUP_SIZE    (sizeof(TransactionId) * MULTIXACT_MEMBERS_PER_MEMBERGROUP + MULTIXACT_FLAGBYTES_PER_GROUP)

Definition at line 69 of file multixact_read_v18.c.

{
    return offset / MULTIXACT_MEMBERS_PER_PAGE;
}
 
/* Location (byte offset within page) of flag word for a given member */
static inline int
MXOffsetToFlagsOffset(MultiXactOffset32 offset)
{
    MultiXactOffset32 group = offset / MULTIXACT_MEMBERS_PER_MEMBERGROUP;
    int         grouponpg = group % MULTIXACT_MEMBERGROUPS_PER_PAGE;
    int         byteoff = grouponpg * MULTIXACT_MEMBERGROUP_SIZE;
 
    return byteoff;
}
 
/* Location (byte offset within page) of TransactionId of given member */
static inline int
MXOffsetToMemberOffset(MultiXactOffset32 offset)
{
    int         member_in_group = offset % MULTIXACT_MEMBERS_PER_MEMBERGROUP;
 
    return MXOffsetToFlagsOffset(offset) +
        MULTIXACT_FLAGBYTES_PER_GROUP +
        member_in_group * sizeof(TransactionId);
}
 
static inline int
MXOffsetToFlagsBitShift(MultiXactOffset32 offset)
{
    int         member_in_group = offset % MULTIXACT_MEMBERS_PER_MEMBERGROUP;
    int         bshift = member_in_group * MXACT_MEMBER_BITS_PER_XACT;
 
    return bshift;
}
 
/*
 * Construct reader of old multixacts.
 *
 * Returns the malloced memory used by the all other calls in this module.
 */
OldMultiXactReader *
AllocOldMultiXactRead(char *pgdata, MultiXactId nextMulti,
                      MultiXactOffset32 nextOffset)
{
    OldMultiXactReader *state = pg_malloc_object(OldMultiXactReader);
    char        dir[MAXPGPATH] = {0};
 
    state->nextMXact = nextMulti;
    state->nextOffset = nextOffset;
 
    pg_sprintf(dir, "%s/pg_multixact/offsets", pgdata);
    state->offset = AllocSlruRead(dir, false);
 
    pg_sprintf(dir, "%s/pg_multixact/members", pgdata);
    state->members = AllocSlruRead(dir, false);
 
    return state;
}
 
/*
 * This is a simplified version of the GetMultiXactIdMembers() server
 * function:
 *
 * - Only return the updating member, if any.  Upgrade only cares about the
 *   updaters.  If there is no updating member, return somewhat arbitrarily
 *   the first locking-only member, because we don't have any way to represent
 *   "no members".
 *
 * - Because there's no concurrent activity, we don't need to worry about
 *   locking and some corner cases.
 *
 * - Don't bail out on invalid entries that could've been left behind after a
 *   server crash.  Such multixids won't appear anywhere else on disk, so the
 *   server will never try to read them.  During upgrade, however, we scan
 *   through all multixids in order, and will encounter such invalid but
 *   unreferenced multixids too.  We try to distinguish between entries that
 *   are invalid because of missed disk writes, like entries with zeros in
 *   offsets or members, and entries that look corrupt in other ways that
 *   should not happen even on a server crash.
 *
 * Returns true on success, false if the multixact was invalid.
 */
bool
GetOldMultiXactIdSingleMember(OldMultiXactReader *state, MultiXactId multi,
                              MultiXactMember *member)
{
    MultiXactId nextMXact,
                nextOffset,
                tmpMXact;
    int64       pageno,
                prev_pageno;
    int         entryno,
                length;
    char       *buf;
    MultiXactOffset32 *offptr,
                offset;
    MultiXactOffset32 nextMXOffset;
    TransactionId result_xid = InvalidTransactionId;
    MultiXactStatus result_status = 0;
 
    nextMXact = state->nextMXact;
    nextOffset = state->nextOffset;
 
    /*
     * Comment copied from GetMultiXactIdMembers in PostgreSQL v18
     * multixact.c:
     *
     * Find out the offset at which we need to start reading MultiXactMembers
     * and the number of members in the multixact.  We determine the latter as
     * the difference between this multixact's starting offset and the next
     * one's.  However, there are some corner cases to worry about:
     *
     * 1. This multixact may be the latest one created, in which case there is
     * no next one to look at.  The next multixact's offset should be set
     * already, as we set it in RecordNewMultiXact(), but we used to not do
     * that in older minor versions.  To cope with that case, if this
     * multixact is the latest one created, use the nextOffset value we read
     * above as the endpoint.
     *
     * 2. Because GetNewMultiXactId skips over offset zero, to reserve zero
     * for to mean "unset", there is an ambiguity near the point of offset
     * wraparound.  If we see next multixact's offset is one, is that our
     * multixact's actual endpoint, or did it end at zero with a subsequent
     * increment?  We handle this using the knowledge that if the zero'th
     * member slot wasn't filled, it'll contain zero, and zero isn't a valid
     * transaction ID so it can't be a multixact member.  Therefore, if we
     * read a zero from the members array, just ignore it.
     */
 
    pageno = MultiXactIdToOffsetPage(multi);
    entryno = MultiXactIdToOffsetEntry(multi);
 
    buf = SlruReadSwitchPage(state->offset, pageno);
    offptr = (MultiXactOffset32 *) buf;
    offptr += entryno;
    offset = *offptr;
 
    if (offset == 0)
    {
        /* Invalid entry.  These can be left behind on a server crash. */
        return false;
    }
 
    /*
     * Use the same increment rule as GetNewMultiXactId(), that is, don't
     * handle wraparound explicitly until needed.
     */
    tmpMXact = multi + 1;
 
    if (nextMXact == tmpMXact)
    {
        /* Corner case 1: there is no next multixact */
        nextMXOffset = nextOffset;
    }
    else
    {
        /* handle wraparound if needed */
        if (tmpMXact < FirstMultiXactId)
            tmpMXact = FirstMultiXactId;
 
        prev_pageno = pageno;
 
        pageno = MultiXactIdToOffsetPage(tmpMXact);
        entryno = MultiXactIdToOffsetEntry(tmpMXact);
 
        if (pageno != prev_pageno)
            buf = SlruReadSwitchPage(state->offset, pageno);
 
        offptr = (MultiXactOffset32 *) buf;
        offptr += entryno;
        nextMXOffset = *offptr;
    }
 
    if (nextMXOffset == 0)
    {
        /* Invalid entry.  These can be left behind on a server crash. */
        return false;
    }
    length = nextMXOffset - offset;
 
    if (length < 0)
    {
        /*
         * This entry is corrupt.  We should not see these even after a server
         * crash.
         */
        pg_fatal("multixact %u has an invalid length (%d)", multi, length);
    }
    if (length == 0)
    {
        /*
         * Invalid entry.  The server never writes multixids with zero
         * members, but it's not clear if a server crash or using pg_resetwal
         * could leave them behind.  Seems best to accept them.
         */
        return false;
    }
 
    /* read the members */
    prev_pageno = -1;
    for (int i = 0; i < length; i++, offset++)
    {
        TransactionId *xactptr;
        uint32     *flagsptr;
        int         flagsoff;
        int         bshift;
        int         memberoff;
        MultiXactStatus status;
 
        pageno = MXOffsetToMemberPage(offset);
        memberoff = MXOffsetToMemberOffset(offset);
 
        if (pageno != prev_pageno)
        {
            buf = SlruReadSwitchPage(state->members, pageno);
            prev_pageno = pageno;
        }
 
        xactptr = (TransactionId *) (buf + memberoff);
        if (!TransactionIdIsValid(*xactptr))
        {
            /*
             * Corner case 2: offset must have wrapped around to unused slot
             * zero.
             */
            if (offset == 0)
                continue;
 
            /*
             * Otherwise this is an invalid entry that should not be
             * referenced from anywhere in the heap.  These can be left behind
             * on a server crash.  We could return 'false' here, but we prefer
             * to continue reading the members and converting them the best we
             * can, to preserve evidence in case this is corruption that
             * should not have happened.
             */
        }
 
        flagsoff = MXOffsetToFlagsOffset(offset);
        bshift = MXOffsetToFlagsBitShift(offset);
        flagsptr = (uint32 *) (buf + flagsoff);
 
        status = (*flagsptr >> bshift) & MXACT_MEMBER_XACT_BITMASK;
 
        /*
         * Remember the updating XID among the members, or first locking XID
         * if no updating XID.
         */
        if (ISUPDATE_from_mxstatus(status))
        {
            /* sanity check */
            if (ISUPDATE_from_mxstatus(result_status))
            {
                /*
                 * We don't expect to see more than one updating member, even
                 * if the server had crashed.
                 */
                pg_fatal("multixact %u has more than one updating member",
                         multi);
            }
            result_xid = *xactptr;
            result_status = status;
        }
        else if (!TransactionIdIsValid(result_xid))
        {
            result_xid = *xactptr;
            result_status = status;
        }
    }
 
    member->xid = result_xid;
    member->status = result_status;
    return true;
}
 
/*
 * Frees the malloced reader.
 */
void
FreeOldMultiXactReader(OldMultiXactReader *state)
{
    FreeSlruRead(state->offset);
    FreeSlruRead(state->members);
 
    pfree(state);
}

MULTIXACT_MEMBERGROUPS_PER_PAGE

#define MULTIXACT_MEMBERGROUPS_PER_PAGE   (BLCKSZ / MULTIXACT_MEMBERGROUP_SIZE)

Definition at line 71 of file multixact_read_v18.c.

MULTIXACT_MEMBERS_PER_MEMBERGROUP

#define MULTIXACT_MEMBERS_PER_MEMBERGROUP    (MULTIXACT_FLAGBYTES_PER_GROUP * MXACT_MEMBER_FLAGS_PER_BYTE)

Definition at line 66 of file multixact_read_v18.c.

MULTIXACT_MEMBERS_PER_PAGE

#define MULTIXACT_MEMBERS_PER_PAGE    (MULTIXACT_MEMBERGROUPS_PER_PAGE * MULTIXACT_MEMBERS_PER_MEMBERGROUP)

Definition at line 72 of file multixact_read_v18.c.

MULTIXACT_OFFSETS_PER_PAGE

#define MULTIXACT_OFFSETS_PER_PAGE   (BLCKSZ / sizeof(MultiXactOffset32))

Definition at line 33 of file multixact_read_v18.c.

MultiXactOffset

#define MultiXactOffset   should_not_be_used

Definition at line 30 of file multixact_read_v18.c.

MXACT_MEMBER_BITS_PER_XACT

#define MXACT_MEMBER_BITS_PER_XACT   8

Definition at line 60 of file multixact_read_v18.c.

MXACT_MEMBER_FLAGS_PER_BYTE

#define MXACT_MEMBER_FLAGS_PER_BYTE   1

Definition at line 61 of file multixact_read_v18.c.

MXACT_MEMBER_XACT_BITMASK

#define MXACT_MEMBER_XACT_BITMASK   ((1 << MXACT_MEMBER_BITS_PER_XACT) - 1)

Definition at line 62 of file multixact_read_v18.c.

Function Documentation

AllocOldMultiXactRead()

OldMultiXactReader * AllocOldMultiXactRead	(	char *	pgdata,
		MultiXactId	nextMulti,
		MultiXactOffset32	nextOffset
	)

Definition at line 119 of file multixact_read_v18.c.

{
    OldMultiXactReader *state = pg_malloc_object(OldMultiXactReader);
    char        dir[MAXPGPATH] = {0};
 
    state->nextMXact = nextMulti;
    state->nextOffset = nextOffset;
 
    pg_sprintf(dir, "%s/pg_multixact/offsets", pgdata);
    state->offset = AllocSlruRead(dir, false);
 
    pg_sprintf(dir, "%s/pg_multixact/members", pgdata);
    state->members = AllocSlruRead(dir, false);
 
    return state;
}

References AllocSlruRead(), MAXPGPATH, pg_malloc_object, and pg_sprintf().

Referenced by rewrite_multixacts().

FreeOldMultiXactReader()

void FreeOldMultiXactReader

(

OldMultiXactReader *

state

)

Definition at line 357 of file multixact_read_v18.c.

{
    FreeSlruRead(state->offset);
    FreeSlruRead(state->members);
 
    pfree(state);
}

References FreeSlruRead(), and pfree().

Referenced by rewrite_multixacts().

GetOldMultiXactIdSingleMember()

bool GetOldMultiXactIdSingleMember	(	OldMultiXactReader *	state,
		MultiXactId	multi,
		MultiXactMember *	member
	)

Definition at line 161 of file multixact_read_v18.c.

{
    MultiXactId nextMXact,
                nextOffset,
                tmpMXact;
    int64       pageno,
                prev_pageno;
    int         entryno,
                length;
    char       *buf;
    MultiXactOffset32 *offptr,
                offset;
    MultiXactOffset32 nextMXOffset;
    TransactionId result_xid = InvalidTransactionId;
    MultiXactStatus result_status = 0;
 
    nextMXact = state->nextMXact;
    nextOffset = state->nextOffset;
 
    /*
     * Comment copied from GetMultiXactIdMembers in PostgreSQL v18
     * multixact.c:
     *
     * Find out the offset at which we need to start reading MultiXactMembers
     * and the number of members in the multixact.  We determine the latter as
     * the difference between this multixact's starting offset and the next
     * one's.  However, there are some corner cases to worry about:
     *
     * 1. This multixact may be the latest one created, in which case there is
     * no next one to look at.  The next multixact's offset should be set
     * already, as we set it in RecordNewMultiXact(), but we used to not do
     * that in older minor versions.  To cope with that case, if this
     * multixact is the latest one created, use the nextOffset value we read
     * above as the endpoint.
     *
     * 2. Because GetNewMultiXactId skips over offset zero, to reserve zero
     * for to mean "unset", there is an ambiguity near the point of offset
     * wraparound.  If we see next multixact's offset is one, is that our
     * multixact's actual endpoint, or did it end at zero with a subsequent
     * increment?  We handle this using the knowledge that if the zero'th
     * member slot wasn't filled, it'll contain zero, and zero isn't a valid
     * transaction ID so it can't be a multixact member.  Therefore, if we
     * read a zero from the members array, just ignore it.
     */
 
    pageno = MultiXactIdToOffsetPage(multi);
    entryno = MultiXactIdToOffsetEntry(multi);
 
    buf = SlruReadSwitchPage(state->offset, pageno);
    offptr = (MultiXactOffset32 *) buf;
    offptr += entryno;
    offset = *offptr;
 
    if (offset == 0)
    {
        /* Invalid entry.  These can be left behind on a server crash. */
        return false;
    }
 
    /*
     * Use the same increment rule as GetNewMultiXactId(), that is, don't
     * handle wraparound explicitly until needed.
     */
    tmpMXact = multi + 1;
 
    if (nextMXact == tmpMXact)
    {
        /* Corner case 1: there is no next multixact */
        nextMXOffset = nextOffset;
    }
    else
    {
        /* handle wraparound if needed */
        if (tmpMXact < FirstMultiXactId)
            tmpMXact = FirstMultiXactId;
 
        prev_pageno = pageno;
 
        pageno = MultiXactIdToOffsetPage(tmpMXact);
        entryno = MultiXactIdToOffsetEntry(tmpMXact);
 
        if (pageno != prev_pageno)
            buf = SlruReadSwitchPage(state->offset, pageno);
 
        offptr = (MultiXactOffset32 *) buf;
        offptr += entryno;
        nextMXOffset = *offptr;
    }
 
    if (nextMXOffset == 0)
    {
        /* Invalid entry.  These can be left behind on a server crash. */
        return false;
    }
    length = nextMXOffset - offset;
 
    if (length < 0)
    {
        /*
         * This entry is corrupt.  We should not see these even after a server
         * crash.
         */
        pg_fatal("multixact %u has an invalid length (%d)", multi, length);
    }
    if (length == 0)
    {
        /*
         * Invalid entry.  The server never writes multixids with zero
         * members, but it's not clear if a server crash or using pg_resetwal
         * could leave them behind.  Seems best to accept them.
         */
        return false;
    }
 
    /* read the members */
    prev_pageno = -1;
    for (int i = 0; i < length; i++, offset++)
    {
        TransactionId *xactptr;
        uint32     *flagsptr;
        int         flagsoff;
        int         bshift;
        int         memberoff;
        MultiXactStatus status;
 
        pageno = MXOffsetToMemberPage(offset);
        memberoff = MXOffsetToMemberOffset(offset);
 
        if (pageno != prev_pageno)
        {
            buf = SlruReadSwitchPage(state->members, pageno);
            prev_pageno = pageno;
        }
 
        xactptr = (TransactionId *) (buf + memberoff);
        if (!TransactionIdIsValid(*xactptr))
        {
            /*
             * Corner case 2: offset must have wrapped around to unused slot
             * zero.
             */
            if (offset == 0)
                continue;
 
            /*
             * Otherwise this is an invalid entry that should not be
             * referenced from anywhere in the heap.  These can be left behind
             * on a server crash.  We could return 'false' here, but we prefer
             * to continue reading the members and converting them the best we
             * can, to preserve evidence in case this is corruption that
             * should not have happened.
             */
        }
 
        flagsoff = MXOffsetToFlagsOffset(offset);
        bshift = MXOffsetToFlagsBitShift(offset);
        flagsptr = (uint32 *) (buf + flagsoff);
 
        status = (*flagsptr >> bshift) & MXACT_MEMBER_XACT_BITMASK;
 
        /*
         * Remember the updating XID among the members, or first locking XID
         * if no updating XID.
         */
        if (ISUPDATE_from_mxstatus(status))
        {
            /* sanity check */
            if (ISUPDATE_from_mxstatus(result_status))
            {
                /*
                 * We don't expect to see more than one updating member, even
                 * if the server had crashed.
                 */
                pg_fatal("multixact %u has more than one updating member",
                         multi);
            }
            result_xid = *xactptr;
            result_status = status;
        }
        else if (!TransactionIdIsValid(result_xid))
        {
            result_xid = *xactptr;
            result_status = status;
        }
    }
 
    member->xid = result_xid;
    member->status = result_status;
    return true;
}

References buf, fb(), FirstMultiXactId, i, InvalidTransactionId, ISUPDATE_from_mxstatus, MultiXactIdToOffsetEntry(), MultiXactIdToOffsetPage(), MXACT_MEMBER_XACT_BITMASK, MXOffsetToFlagsBitShift(), MXOffsetToFlagsOffset(), MXOffsetToMemberOffset(), MXOffsetToMemberPage(), pg_fatal, SlruReadSwitchPage(), MultiXactMember::status, TransactionIdIsValid, and MultiXactMember::xid.

Referenced by rewrite_multixacts().

MultiXactIdToOffsetEntry()

static int MultiXactIdToOffsetEntry ( MultiXactId  multi )

inlinestatic

Definition at line 42 of file multixact_read_v18.c.

{
    return multi % MULTIXACT_OFFSETS_PER_PAGE;
}

References MULTIXACT_OFFSETS_PER_PAGE.

Referenced by ExtendMultiXactOffset(), find_multixact_start(), GetMultiXactIdMembers(), GetOldMultiXactIdSingleMember(), RecordMultiXactOffset(), RecordNewMultiXact(), and TrimMultiXact().

MultiXactIdToOffsetPage()

static int64 MultiXactIdToOffsetPage ( MultiXactId  multi )

inlinestatic

Definition at line 36 of file multixact_read_v18.c.

{
    return multi / MULTIXACT_OFFSETS_PER_PAGE;
}

References MULTIXACT_OFFSETS_PER_PAGE.

Referenced by ExtendMultiXactOffset(), find_multixact_start(), GetMultiXactIdMembers(), GetOldMultiXactIdSingleMember(), multixact_redo(), PerformOffsetsTruncation(), RecordMultiXactOffset(), RecordNewMultiXact(), rewrite_multixacts(), StartupMultiXact(), and TrimMultiXact().

MXOffsetToFlagsBitShift()

static int MXOffsetToFlagsBitShift ( MultiXactOffset32  offset )

inlinestatic

Definition at line 105 of file multixact_read_v18.c.

{
    int         member_in_group = offset % MULTIXACT_MEMBERS_PER_MEMBERGROUP;
    int         bshift = member_in_group * MXACT_MEMBER_BITS_PER_XACT;
 
    return bshift;
}

References fb(), MULTIXACT_MEMBERS_PER_MEMBERGROUP, and MXACT_MEMBER_BITS_PER_XACT.

Referenced by ExtendMultiXactMember(), GetMultiXactIdMembers(), GetOldMultiXactIdSingleMember(), RecordMultiXactMembers(), and RecordNewMultiXact().

MXOffsetToFlagsOffset()

static int MXOffsetToFlagsOffset ( MultiXactOffset32  offset )

inlinestatic

Definition at line 84 of file multixact_read_v18.c.

{
    MultiXactOffset32 group = offset / MULTIXACT_MEMBERS_PER_MEMBERGROUP;
    int         grouponpg = group % MULTIXACT_MEMBERGROUPS_PER_PAGE;
    int         byteoff = grouponpg * MULTIXACT_MEMBERGROUP_SIZE;
 
    return byteoff;
}

References fb(), MULTIXACT_MEMBERGROUP_SIZE, MULTIXACT_MEMBERGROUPS_PER_PAGE, and MULTIXACT_MEMBERS_PER_MEMBERGROUP.

Referenced by ExtendMultiXactMember(), GetMultiXactIdMembers(), GetOldMultiXactIdSingleMember(), MXOffsetToMemberOffset(), RecordMultiXactMembers(), RecordNewMultiXact(), and TrimMultiXact().

MXOffsetToMemberOffset()

static int MXOffsetToMemberOffset ( MultiXactOffset32  offset )

inlinestatic

Definition at line 95 of file multixact_read_v18.c.

{
    int         member_in_group = offset % MULTIXACT_MEMBERS_PER_MEMBERGROUP;
 
    return MXOffsetToFlagsOffset(offset) +
        MULTIXACT_FLAGBYTES_PER_GROUP +
        member_in_group * sizeof(TransactionId);
}

References fb(), MULTIXACT_FLAGBYTES_PER_GROUP, MULTIXACT_MEMBERS_PER_MEMBERGROUP, and MXOffsetToFlagsOffset().

Referenced by GetMultiXactIdMembers(), GetOldMultiXactIdSingleMember(), RecordMultiXactMembers(), RecordNewMultiXact(), and TrimMultiXact().

MXOffsetToMemberPage()

static int64 MXOffsetToMemberPage ( MultiXactOffset32  offset )

inlinestatic

Definition at line 77 of file multixact_read_v18.c.

{
    return offset / MULTIXACT_MEMBERS_PER_PAGE;
}

References MULTIXACT_MEMBERS_PER_PAGE.

Referenced by ExtendMultiXactMember(), GetMultiXactIdMembers(), GetOldMultiXactIdSingleMember(), PerformMembersTruncation(), RecordMultiXactMembers(), RecordNewMultiXact(), rewrite_multixacts(), StartupMultiXact(), and TrimMultiXact().