multixact_read_v18.h File Reference

#include "access/multixact.h"
#include "slru_io.h"

Include dependency graph for multixact_read_v18.h:

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

Go to the source code of this file.

Data Structures
struct	OldMultiXactReader

Typedefs
typedef uint32	MultiXactOffset32
typedef struct OldMultiXactReader	OldMultiXactReader

Functions
OldMultiXactReader *	AllocOldMultiXactRead (char *pgdata, MultiXactId nextMulti, MultiXactOffset32 nextOffset)
bool	GetOldMultiXactIdSingleMember (OldMultiXactReader *state, MultiXactId multi, MultiXactMember *member)
void	FreeOldMultiXactReader (OldMultiXactReader *reader)

Typedef Documentation

MultiXactOffset32

typedef uint32 MultiXactOffset32

Definition at line 18 of file multixact_read_v18.h.

OldMultiXactReader

typedef struct OldMultiXactReader OldMultiXactReader

Function Documentation

AllocOldMultiXactRead()

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

Definition at line 119 of file multixact_read_v18.c.

{
    OldMultiXactReader *state = state = pg_malloc(sizeof(*state));
    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(), and pg_sprintf().

Referenced by rewrite_multixacts().

FreeOldMultiXactReader()

void FreeOldMultiXactReader

(

OldMultiXactReader *

reader

)

Definition at line 334 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 158 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 */
        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 */
        return false;
    }
    length = nextMXOffset - offset;
 
    /* 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: we are looking at unused slot zero
             */
            if (offset == 0)
                continue;
 
            /*
             * Otherwise this is an invalid entry that should not be
             * referenced from anywhere in the heap.  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 happen.
             */
        }
 
        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().