multixact_rewrite.c File Reference

#include "postgres_fe.h"
#include "access/multixact_internal.h"
#include "multixact_read_v18.h"
#include "pg_upgrade.h"

Include dependency graph for multixact_rewrite.c:

Go to the source code of this file.

Functions
static void	RecordMultiXactOffset (SlruSegState *offsets_writer, MultiXactId multi, MultiXactOffset offset)
static void	RecordMultiXactMembers (SlruSegState *members_writer, MultiXactOffset offset, int nmembers, MultiXactMember *members)
MultiXactOffset	rewrite_multixacts (MultiXactId from_multi, MultiXactId to_multi)

Function Documentation

RecordMultiXactMembers()

static void RecordMultiXactMembers ( SlruSegState *  members_writer, MultiXactOffset  offset, int  nmembers, MultiXactMember *  members  )

static

Definition at line 156 of file multixact_rewrite.c.

{
    for (int i = 0; i < nmembers; i++, offset++)
    {
        int64       pageno;
        char       *buf;
        TransactionId *memberptr;
        uint32     *flagsptr;
        uint32      flagsval;
        int         bshift;
        int         flagsoff;
        int         memberoff;
 
        Assert(members[i].status <= MultiXactStatusUpdate);
 
        pageno = MXOffsetToMemberPage(offset);
        memberoff = MXOffsetToMemberOffset(offset);
        flagsoff = MXOffsetToFlagsOffset(offset);
        bshift = MXOffsetToFlagsBitShift(offset);
 
        buf = SlruWriteSwitchPage(members_writer, pageno);
 
        memberptr = (TransactionId *) (buf + memberoff);
 
        *memberptr = members[i].xid;
 
        flagsptr = (uint32 *) (buf + flagsoff);
 
        flagsval = *flagsptr;
        flagsval &= ~(((1 << MXACT_MEMBER_BITS_PER_XACT) - 1) << bshift);
        flagsval |= (members[i].status << bshift);
        *flagsptr = flagsval;
    }
}

References Assert, buf, fb(), i, MultiXactStatusUpdate, MXACT_MEMBER_BITS_PER_XACT, MXOffsetToFlagsBitShift(), MXOffsetToFlagsOffset(), MXOffsetToMemberOffset(), MXOffsetToMemberPage(), SlruWriteSwitchPage(), MultiXactMember::status, and MultiXactMember::xid.

Referenced by rewrite_multixacts().

RecordMultiXactOffset()

static void RecordMultiXactOffset ( SlruSegState *  offsets_writer, MultiXactId  multi, MultiXactOffset  offset  )

static

Definition at line 134 of file multixact_rewrite.c.

{
    int64       pageno;
    int         entryno;
    char       *buf;
    MultiXactOffset *offptr;
 
    pageno = MultiXactIdToOffsetPage(multi);
    entryno = MultiXactIdToOffsetEntry(multi);
 
    buf = SlruWriteSwitchPage(offsets_writer, pageno);
    offptr = (MultiXactOffset *) buf;
    offptr[entryno] = offset;
}

References buf, fb(), MultiXactIdToOffsetEntry(), MultiXactIdToOffsetPage(), and SlruWriteSwitchPage().

Referenced by rewrite_multixacts().

rewrite_multixacts()

MultiXactOffset rewrite_multixacts	(	MultiXactId	from_multi,
		MultiXactId	to_multi
	)

Definition at line 38 of file multixact_rewrite.c.

{
    MultiXactOffset next_offset;
    SlruSegState *offsets_writer;
    SlruSegState *members_writer;
    char        dir[MAXPGPATH] = {0};
    bool        prev_multixid_valid = false;
 
    /*
     * The range of valid multi XIDs is unchanged by the conversion (they are
     * referenced from the heap tables), but the members SLRU is rewritten to
     * start from offset 1.
     */
    next_offset = 1;
 
    /* Prepare to write the new SLRU files */
    pg_sprintf(dir, "%s/pg_multixact/offsets", new_cluster.pgdata);
    offsets_writer = AllocSlruWrite(dir, false);
    SlruWriteSwitchPage(offsets_writer, MultiXactIdToOffsetPage(from_multi));
 
    pg_sprintf(dir, "%s/pg_multixact/members", new_cluster.pgdata);
    members_writer = AllocSlruWrite(dir, true /* use long segment names */ );
    SlruWriteSwitchPage(members_writer, MXOffsetToMemberPage(next_offset));
 
    /*
     * Convert old multixids, if needed, by reading them one-by-one from the
     * old cluster.
     */
    if (to_multi != from_multi)
    {
        OldMultiXactReader *old_reader;
 
        old_reader = AllocOldMultiXactRead(old_cluster.pgdata,
                                           old_cluster.controldata.chkpnt_nxtmulti,
                                           old_cluster.controldata.chkpnt_nxtmxoff);
 
        for (MultiXactId multi = from_multi; multi != to_multi;)
        {
            MultiXactMember member;
            bool        multixid_valid;
 
            /*
             * Read this multixid's members.
             *
             * Locking-only XIDs that may be part of multi-xids don't matter
             * after upgrade, as there can be no transactions running across
             * upgrade.  So as a small optimization, we only read one member
             * from each multixid: the one updating one, or if there was no
             * update, arbitrarily the first locking xid.
             */
            multixid_valid = GetOldMultiXactIdSingleMember(old_reader, multi, &member);
 
            /*
             * Write the new offset to pg_multixact/offsets.
             *
             * Even if this multixid is invalid, we still need to write its
             * offset if the *previous* multixid was valid.  That's because
             * when reading a multixid, the number of members is calculated
             * from the difference between the two offsets.
             */
            RecordMultiXactOffset(offsets_writer, multi,
                                  (multixid_valid || prev_multixid_valid) ? next_offset : 0);
 
            /* Write the members */
            if (multixid_valid)
            {
                RecordMultiXactMembers(members_writer, next_offset, 1, &member);
                next_offset += 1;
            }
 
            /* Advance to next multixid, handling wraparound */
            multi++;
            if (multi < FirstMultiXactId)
                multi = FirstMultiXactId;
            prev_multixid_valid = multixid_valid;
        }
 
        FreeOldMultiXactReader(old_reader);
    }
 
    /* Write the final 'next' offset to the last SLRU page */
    RecordMultiXactOffset(offsets_writer, to_multi,
                          prev_multixid_valid ? next_offset : 0);
 
    /* Flush the last SLRU pages */
    FreeSlruWrite(offsets_writer);
    FreeSlruWrite(members_writer);
 
    return next_offset;
}

References AllocOldMultiXactRead(), AllocSlruWrite(), ControlData::chkpnt_nxtmulti, ControlData::chkpnt_nxtmxoff, ClusterInfo::controldata, fb(), FirstMultiXactId, FreeOldMultiXactReader(), FreeSlruWrite(), GetOldMultiXactIdSingleMember(), MAXPGPATH, MultiXactIdToOffsetPage(), MXOffsetToMemberPage(), new_cluster, old_cluster, pg_sprintf(), ClusterInfo::pgdata, RecordMultiXactMembers(), RecordMultiXactOffset(), and SlruWriteSwitchPage().

Referenced by copy_xact_xlog_xid().