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.

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, 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 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 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 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().