mcxt.c File Reference

#include "postgres.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "utils/memdebug.h"
#include "utils/memutils.h"
#include "utils/memutils_internal.h"
#include "utils/memutils_memorychunk.h"

Include dependency graph for mcxt.c:

Go to the source code of this file.

Macros
#define	BOGUS_MCTX(id)
#define	AssertNotInCriticalSection(context)    Assert(CritSectionCount == 0 || (context)->allowInCritSection)
#define	MCXT_METHOD(pointer, method)    mcxt_methods[GetMemoryChunkMethodID(pointer)].method

Functions
static void	BogusFree (void *pointer)
static void *	BogusRealloc (void *pointer, Size size, int flags)
static MemoryContext	BogusGetChunkContext (void *pointer)
static Size	BogusGetChunkSpace (void *pointer)
static void	MemoryContextDeleteOnly (MemoryContext context)
static void	MemoryContextCallResetCallbacks (MemoryContext context)
static void	MemoryContextStatsInternal (MemoryContext context, int level, int max_level, int max_children, MemoryContextCounters *totals, bool print_to_stderr)
static void	MemoryContextStatsPrint (MemoryContext context, void *passthru, const char *stats_string, bool print_to_stderr)
static MemoryContextMethodID	GetMemoryChunkMethodID (const void *pointer)
static uint64	GetMemoryChunkHeader (const void *pointer)
static MemoryContext	MemoryContextTraverseNext (MemoryContext curr, MemoryContext top)
void	MemoryContextInit (void)
void	MemoryContextReset (MemoryContext context)
void	MemoryContextResetOnly (MemoryContext context)
void	MemoryContextResetChildren (MemoryContext context)
void	MemoryContextDelete (MemoryContext context)
void	MemoryContextDeleteChildren (MemoryContext context)
void	MemoryContextRegisterResetCallback (MemoryContext context, MemoryContextCallback *cb)
void	MemoryContextUnregisterResetCallback (MemoryContext context, MemoryContextCallback *cb)
void	MemoryContextSetIdentifier (MemoryContext context, const char *id)
void	MemoryContextSetParent (MemoryContext context, MemoryContext new_parent)
void	MemoryContextAllowInCriticalSection (MemoryContext context, bool allow)
MemoryContext	GetMemoryChunkContext (void *pointer)
Size	GetMemoryChunkSpace (void *pointer)
MemoryContext	MemoryContextGetParent (MemoryContext context)
bool	MemoryContextIsEmpty (MemoryContext context)
Size	MemoryContextMemAllocated (MemoryContext context, bool recurse)
void	MemoryContextMemConsumed (MemoryContext context, MemoryContextCounters *consumed)
void	MemoryContextStats (MemoryContext context)
void	MemoryContextStatsDetail (MemoryContext context, int max_level, int max_children, bool print_to_stderr)
void	MemoryContextCreate (MemoryContext node, NodeTag tag, MemoryContextMethodID method_id, MemoryContext parent, const char *name)
void *	MemoryContextAllocationFailure (MemoryContext context, Size size, int flags)
void	MemoryContextSizeFailure (MemoryContext context, Size size, int flags)
void *	MemoryContextAlloc (MemoryContext context, Size size)
void *	MemoryContextAllocZero (MemoryContext context, Size size)
void *	MemoryContextAllocExtended (MemoryContext context, Size size, int flags)
void	HandleLogMemoryContextInterrupt (void)
void	ProcessLogMemoryContextInterrupt (void)
void *	palloc (Size size)
void *	palloc0 (Size size)
void *	palloc_extended (Size size, int flags)
void *	MemoryContextAllocAligned (MemoryContext context, Size size, Size alignto, int flags)
void *	palloc_aligned (Size size, Size alignto, int flags)
void	pfree (void *pointer)
void *	repalloc (void *pointer, Size size)
void *	repalloc_extended (void *pointer, Size size, int flags)
void *	repalloc0 (void *pointer, Size oldsize, Size size)
void *	MemoryContextAllocHuge (MemoryContext context, Size size)
void *	repalloc_huge (void *pointer, Size size)
char *	MemoryContextStrdup (MemoryContext context, const char *string)
char *	pstrdup (const char *in)
char *	pnstrdup (const char *in, Size len)
char *	pchomp (const char *in)

Variables
static const MemoryContextMethods	mcxt_methods []
MemoryContext	CurrentMemoryContext = NULL
MemoryContext	TopMemoryContext = NULL
MemoryContext	ErrorContext = NULL
MemoryContext	PostmasterContext = NULL
MemoryContext	CacheMemoryContext = NULL
MemoryContext	MessageContext = NULL
MemoryContext	TopTransactionContext = NULL
MemoryContext	CurTransactionContext = NULL
MemoryContext	PortalContext = NULL
static bool	LogMemoryContextInProgress = false

Macro Definition Documentation

AssertNotInCriticalSection

#define AssertNotInCriticalSection

(

context

)

Assert(CritSectionCount == 0 || (context)->allowInCritSection)

Definition at line 195 of file mcxt.c.

{
    uint64      header;
 
    /*
     * Try to detect bogus pointers handed to us, poorly though we can.
     * Presumably, a pointer that isn't MAXALIGNED isn't pointing at an
     * allocated chunk.
     */
    Assert(pointer == (const void *) MAXALIGN(pointer));
 
    /* Allow access to the uint64 header */
    VALGRIND_MAKE_MEM_DEFINED((char *) pointer - sizeof(uint64), sizeof(uint64));
 
    header = *((const uint64 *) ((const char *) pointer - sizeof(uint64)));
 
    /* Disallow access to the uint64 header */
    VALGRIND_MAKE_MEM_NOACCESS((char *) pointer - sizeof(uint64), sizeof(uint64));
 
    return (MemoryContextMethodID) (header & MEMORY_CONTEXT_METHODID_MASK);
}
 
/*
 * GetMemoryChunkHeader
 *      Return the uint64 chunk header which directly precedes 'pointer'.
 *
 * This is only used after GetMemoryChunkMethodID, so no need for error checks.
 */
static inline uint64
GetMemoryChunkHeader(const void *pointer)
{
    uint64      header;
 
    /* Allow access to the uint64 header */
    VALGRIND_MAKE_MEM_DEFINED((char *) pointer - sizeof(uint64), sizeof(uint64));
 
    header = *((const uint64 *) ((const char *) pointer - sizeof(uint64)));
 
    /* Disallow access to the uint64 header */
    VALGRIND_MAKE_MEM_NOACCESS((char *) pointer - sizeof(uint64), sizeof(uint64));
 
    return header;
}
 
/*
 * MemoryContextTraverseNext
 *      Helper function to traverse all descendants of a memory context
 *      without recursion.
 *
 * Recursion could lead to out-of-stack errors with deep context hierarchies,
 * which would be unpleasant in error cleanup code paths.
 *
 * To process 'context' and all its descendants, use a loop like this:
 *
 *     <process 'context'>
 *     for (MemoryContext curr = context->firstchild;
 *          curr != NULL;
 *          curr = MemoryContextTraverseNext(curr, context))
 *     {
 *         <process 'curr'>
 *     }
 *
 * This visits all the contexts in pre-order, that is a node is visited
 * before its children.
 */
static MemoryContext
MemoryContextTraverseNext(MemoryContext curr, MemoryContext top)
{
    /* After processing a node, traverse to its first child if any */
    if (curr->firstchild != NULL)
        return curr->firstchild;
 
    /*
     * After processing a childless node, traverse to its next sibling if
     * there is one.  If there isn't, traverse back up to the parent (which
     * has already been visited, and now so have all its descendants).  We're
     * done if that is "top", otherwise traverse to its next sibling if any,
     * otherwise repeat moving up.
     */
    while (curr->nextchild == NULL)
    {
        curr = curr->parent;
        if (curr == top)
            return NULL;
    }
    return curr->nextchild;
}
 
/*
 * Support routines to trap use of invalid memory context method IDs
 * (from calling pfree or the like on a bogus pointer).  As a possible
 * aid in debugging, we report the header word along with the pointer
 * address (if we got here, there must be an accessible header word).
 */
static void
BogusFree(void *pointer)
{
    elog(ERROR, "pfree called with invalid pointer %p (header 0x%016" PRIx64 ")",
         pointer, GetMemoryChunkHeader(pointer));
}
 
static void *
BogusRealloc(void *pointer, Size size, int flags)
{
    elog(ERROR, "repalloc called with invalid pointer %p (header 0x%016" PRIx64 ")",
         pointer, GetMemoryChunkHeader(pointer));
    return NULL;                /* keep compiler quiet */
}
 
static MemoryContext
BogusGetChunkContext(void *pointer)
{
    elog(ERROR, "GetMemoryChunkContext called with invalid pointer %p (header 0x%016" PRIx64 ")",
         pointer, GetMemoryChunkHeader(pointer));
    return NULL;                /* keep compiler quiet */
}
 
static Size
BogusGetChunkSpace(void *pointer)
{
    elog(ERROR, "GetMemoryChunkSpace called with invalid pointer %p (header 0x%016" PRIx64 ")",
         pointer, GetMemoryChunkHeader(pointer));
    return 0;                   /* keep compiler quiet */
}
 
 
/*****************************************************************************
 *    EXPORTED ROUTINES                                                      *
 *****************************************************************************/
 
 
/*
 * MemoryContextInit
 *      Start up the memory-context subsystem.
 *
 * This must be called before creating contexts or allocating memory in
 * contexts.  TopMemoryContext and ErrorContext are initialized here;
 * other contexts must be created afterwards.
 *
 * In normal multi-backend operation, this is called once during
 * postmaster startup, and not at all by individual backend startup
 * (since the backends inherit an already-initialized context subsystem
 * by virtue of being forked off the postmaster).  But in an EXEC_BACKEND
 * build, each process must do this for itself.
 *
 * In a standalone backend this must be called during backend startup.
 */
void
MemoryContextInit(void)
{
    Assert(TopMemoryContext == NULL);
 
    /*
     * First, initialize TopMemoryContext, which is the parent of all others.
     */
    TopMemoryContext = AllocSetContextCreate((MemoryContext) NULL,
                                             "TopMemoryContext",
                                             ALLOCSET_DEFAULT_SIZES);
 
    /*
     * Not having any other place to point CurrentMemoryContext, make it point
     * to TopMemoryContext.  Caller should change this soon!
     */
    CurrentMemoryContext = TopMemoryContext;
 
    /*
     * Initialize ErrorContext as an AllocSetContext with slow growth rate ---
     * we don't really expect much to be allocated in it. More to the point,
     * require it to contain at least 8K at all times. This is the only case
     * where retained memory in a context is *essential* --- we want to be
     * sure ErrorContext still has some memory even if we've run out
     * elsewhere! Also, allow allocations in ErrorContext within a critical
     * section. Otherwise a PANIC will cause an assertion failure in the error
     * reporting code, before printing out the real cause of the failure.
     *
     * This should be the last step in this function, as elog.c assumes memory
     * management works once ErrorContext is non-null.
     */
    ErrorContext = AllocSetContextCreate(TopMemoryContext,
                                         "ErrorContext",
                                         8 * 1024,
                                         8 * 1024,
                                         8 * 1024);
    MemoryContextAllowInCriticalSection(ErrorContext, true);
}
 
/*
 * MemoryContextReset
 *      Release all space allocated within a context and delete all its
 *      descendant contexts (but not the named context itself).
 */
void
MemoryContextReset(MemoryContext context)
{
    Assert(MemoryContextIsValid(context));
 
    /* save a function call in common case where there are no children */
    if (context->firstchild != NULL)
        MemoryContextDeleteChildren(context);
 
    /* save a function call if no pallocs since startup or last reset */
    if (!context->isReset)
        MemoryContextResetOnly(context);
}
 
/*
 * MemoryContextResetOnly
 *      Release all space allocated within a context.
 *      Nothing is done to the context's descendant contexts.
 */
void
MemoryContextResetOnly(MemoryContext context)
{
    Assert(MemoryContextIsValid(context));
 
    /* Nothing to do if no pallocs since startup or last reset */
    if (!context->isReset)
    {
        MemoryContextCallResetCallbacks(context);
 
        /*
         * If context->ident points into the context's memory, it will become
         * a dangling pointer.  We could prevent that by setting it to NULL
         * here, but that would break valid coding patterns that keep the
         * ident elsewhere, e.g. in a parent context.  So for now we assume
         * the programmer got it right.
         */
 
        context->methods->reset(context);
        context->isReset = true;
    }
}
 
/*
 * MemoryContextResetChildren
 *      Release all space allocated within a context's descendants,
 *      but don't delete the contexts themselves.  The named context
 *      itself is not touched.
 */
void
MemoryContextResetChildren(MemoryContext context)
{
    Assert(MemoryContextIsValid(context));
 
    for (MemoryContext curr = context->firstchild;
         curr != NULL;
         curr = MemoryContextTraverseNext(curr, context))
    {
        MemoryContextResetOnly(curr);
    }
}
 
/*
 * MemoryContextDelete
 *      Delete a context and its descendants, and release all space
 *      allocated therein.
 *
 * The type-specific delete routine removes all storage for the context,
 * but we have to deal with descendant nodes here.
 */
void
MemoryContextDelete(MemoryContext context)
{
    MemoryContext curr;
 
    Assert(MemoryContextIsValid(context));
 
    /*
     * Delete subcontexts from the bottom up.
     *
     * Note: Do not use recursion here.  A "stack depth limit exceeded" error
     * would be unpleasant if we're already in the process of cleaning up from
     * transaction abort.  We also cannot use MemoryContextTraverseNext() here
     * because we modify the tree as we go.
     */
    curr = context;
    for (;;)
    {
        MemoryContext parent;
 
        /* Descend down until we find a leaf context with no children */
        while (curr->firstchild != NULL)
            curr = curr->firstchild;
 
        /*
         * We're now at a leaf with no children. Free it and continue from the
         * parent.  Or if this was the original node, we're all done.
         */
        parent = curr->parent;
        MemoryContextDeleteOnly(curr);
 
        if (curr == context)
            break;
        curr = parent;
    }
}
 
/*
 * Subroutine of MemoryContextDelete,
 * to delete a context that has no children.
 * We must also delink the context from its parent, if it has one.
 */
static void
MemoryContextDeleteOnly(MemoryContext context)
{
    Assert(MemoryContextIsValid(context));
    /* We had better not be deleting TopMemoryContext ... */
    Assert(context != TopMemoryContext);
    /* And not CurrentMemoryContext, either */
    Assert(context != CurrentMemoryContext);
    /* All the children should've been deleted already */
    Assert(context->firstchild == NULL);
 
    /*
     * It's not entirely clear whether 'tis better to do this before or after
     * delinking the context; but an error in a callback will likely result in
     * leaking the whole context (if it's not a root context) if we do it
     * after, so let's do it before.
     */
    MemoryContextCallResetCallbacks(context);
 
    /*
     * We delink the context from its parent before deleting it, so that if
     * there's an error we won't have deleted/busted contexts still attached
     * to the context tree.  Better a leak than a crash.
     */
    MemoryContextSetParent(context, NULL);
 
    /*
     * Also reset the context's ident pointer, in case it points into the
     * context.  This would only matter if someone tries to get stats on the
     * (already unlinked) context, which is unlikely, but let's be safe.
     */
    context->ident = NULL;
 
    context->methods->delete_context(context);
}
 
/*
 * MemoryContextDeleteChildren
 *      Delete all the descendants of the named context and release all
 *      space allocated therein.  The named context itself is not touched.
 */
void
MemoryContextDeleteChildren(MemoryContext context)
{
    Assert(MemoryContextIsValid(context));
 
    /*
     * MemoryContextDelete will delink the child from me, so just iterate as
     * long as there is a child.
     */
    while (context->firstchild != NULL)
        MemoryContextDelete(context->firstchild);
}
 
/*
 * MemoryContextRegisterResetCallback
 *      Register a function to be called before next context reset/delete.
 *      Such callbacks will be called in reverse order of registration.
 *
 * The caller is responsible for allocating a MemoryContextCallback struct
 * to hold the info about this callback request, and for filling in the
 * "func" and "arg" fields in the struct to show what function to call with
 * what argument.  Typically the callback struct should be allocated within
 * the specified context, since that means it will automatically be freed
 * when no longer needed.
 *
 * Note that callers can assume this cannot fail.
 */
void
MemoryContextRegisterResetCallback(MemoryContext context,
                                   MemoryContextCallback *cb)
{
    Assert(MemoryContextIsValid(context));
 
    /* Push onto head so this will be called before older registrants. */
    cb->next = context->reset_cbs;
    context->reset_cbs = cb;
    /* Mark the context as non-reset (it probably is already). */
    context->isReset = false;
}
 
/*
 * MemoryContextUnregisterResetCallback
 *      Undo the effects of MemoryContextRegisterResetCallback.
 *
 * This can be used if a callback's effects are no longer required
 * at some point before the context has been reset/deleted.  It is the
 * caller's responsibility to pfree the callback struct (if needed).
 *
 * An assertion failure occurs if the callback was not registered.
 * We could alternatively define that case as a no-op, but that seems too
 * likely to mask programming errors such as passing the wrong context.
 */
void
MemoryContextUnregisterResetCallback(MemoryContext context,
                                     MemoryContextCallback *cb)
{
    MemoryContextCallback *prev,
               *cur;
 
    Assert(MemoryContextIsValid(context));
 
    for (prev = NULL, cur = context->reset_cbs; cur != NULL;
         prev = cur, cur = cur->next)
    {
        if (cur != cb)
            continue;
        if (prev)
            prev->next = cur->next;
        else
            context->reset_cbs = cur->next;
        return;
    }
    Assert(false);
}
 
/*
 * MemoryContextCallResetCallbacks
 *      Internal function to call all registered callbacks for context.
 */
static void
MemoryContextCallResetCallbacks(MemoryContext context)
{
    MemoryContextCallback *cb;
 
    /*
     * We pop each callback from the list before calling.  That way, if an
     * error occurs inside the callback, we won't try to call it a second time
     * in the likely event that we reset or delete the context later.
     */
    while ((cb = context->reset_cbs) != NULL)
    {
        context->reset_cbs = cb->next;
        cb->func(cb->arg);
    }
}
 
/*
 * MemoryContextSetIdentifier
 *      Set the identifier string for a memory context.
 *
 * An identifier can be provided to help distinguish among different contexts
 * of the same kind in memory context stats dumps.  The identifier string
 * must live at least as long as the context it is for; typically it is
 * allocated inside that context, so that it automatically goes away on
 * context deletion.  Pass id = NULL to forget any old identifier.
 */
void
MemoryContextSetIdentifier(MemoryContext context, const char *id)
{
    Assert(MemoryContextIsValid(context));
    context->ident = id;
}
 
/*
 * MemoryContextSetParent
 *      Change a context to belong to a new parent (or no parent).
 *
 * We provide this as an API function because it is sometimes useful to
 * change a context's lifespan after creation.  For example, a context
 * might be created underneath a transient context, filled with data,
 * and then reparented underneath CacheMemoryContext to make it long-lived.
 * In this way no special effort is needed to get rid of the context in case
 * a failure occurs before its contents are completely set up.
 *
 * Callers often assume that this function cannot fail, so don't put any
 * elog(ERROR) calls in it.
 *
 * A possible caller error is to reparent a context under itself, creating
 * a loop in the context graph.  We assert here that context != new_parent,
 * but checking for multi-level loops seems more trouble than it's worth.
 */
void
MemoryContextSetParent(MemoryContext context, MemoryContext new_parent)
{
    Assert(MemoryContextIsValid(context));
    Assert(context != new_parent);
 
    /* Fast path if it's got correct parent already */
    if (new_parent == context->parent)
        return;
 
    /* Delink from existing parent, if any */
    if (context->parent)
    {
        MemoryContext parent = context->parent;
 
        if (context->prevchild != NULL)
            context->prevchild->nextchild = context->nextchild;
        else
        {
            Assert(parent->firstchild == context);
            parent->firstchild = context->nextchild;
        }
 
        if (context->nextchild != NULL)
            context->nextchild->prevchild = context->prevchild;
    }
 
    /* And relink */
    if (new_parent)
    {
        Assert(MemoryContextIsValid(new_parent));
        context->parent = new_parent;
        context->prevchild = NULL;
        context->nextchild = new_parent->firstchild;
        if (new_parent->firstchild != NULL)
            new_parent->firstchild->prevchild = context;
        new_parent->firstchild = context;
    }
    else
    {
        context->parent = NULL;
        context->prevchild = NULL;
        context->nextchild = NULL;
    }
}
 
/*
 * MemoryContextAllowInCriticalSection
 *      Allow/disallow allocations in this memory context within a critical
 *      section.
 *
 * Normally, memory allocations are not allowed within a critical section,
 * because a failure would lead to PANIC.  There are a few exceptions to
 * that, like allocations related to debugging code that is not supposed to
 * be enabled in production.  This function can be used to exempt specific
 * memory contexts from the assertion in palloc().
 */
void
MemoryContextAllowInCriticalSection(MemoryContext context, bool allow)
{
    Assert(MemoryContextIsValid(context));
 
    context->allowInCritSection = allow;
}
 
/*
 * GetMemoryChunkContext
 *      Given a currently-allocated chunk, determine the MemoryContext that
 *      the chunk belongs to.
 */
MemoryContext
GetMemoryChunkContext(void *pointer)
{
    return MCXT_METHOD(pointer, get_chunk_context) (pointer);
}
 
/*
 * GetMemoryChunkSpace
 *      Given a currently-allocated chunk, determine the total space
 *      it occupies (including all memory-allocation overhead).
 *
 * This is useful for measuring the total space occupied by a set of
 * allocated chunks.
 */
Size
GetMemoryChunkSpace(void *pointer)
{
    return MCXT_METHOD(pointer, get_chunk_space) (pointer);
}
 
/*
 * MemoryContextGetParent
 *      Get the parent context (if any) of the specified context
 */
MemoryContext
MemoryContextGetParent(MemoryContext context)
{
    Assert(MemoryContextIsValid(context));
 
    return context->parent;
}
 
/*
 * MemoryContextIsEmpty
 *      Is a memory context empty of any allocated space?
 */
bool
MemoryContextIsEmpty(MemoryContext context)
{
    Assert(MemoryContextIsValid(context));
 
    /*
     * For now, we consider a memory context nonempty if it has any children;
     * perhaps this should be changed later.
     */
    if (context->firstchild != NULL)
        return false;
    /* Otherwise use the type-specific inquiry */
    return context->methods->is_empty(context);
}
 
/*
 * Find the memory allocated to blocks for this memory context. If recurse is
 * true, also include children.
 */
Size
MemoryContextMemAllocated(MemoryContext context, bool recurse)
{
    Size        total = context->mem_allocated;
 
    Assert(MemoryContextIsValid(context));
 
    if (recurse)
    {
        for (MemoryContext curr = context->firstchild;
             curr != NULL;
             curr = MemoryContextTraverseNext(curr, context))
        {
            total += curr->mem_allocated;
        }
    }
 
    return total;
}
 
/*
 * Return the memory consumption statistics about the given context and its
 * children.
 */
void
MemoryContextMemConsumed(MemoryContext context,
                         MemoryContextCounters *consumed)
{
    Assert(MemoryContextIsValid(context));
 
    memset(consumed, 0, sizeof(*consumed));
 
    /* Examine the context itself */
    context->methods->stats(context, NULL, NULL, consumed, false);
 
    /* Examine children, using iteration not recursion */
    for (MemoryContext curr = context->firstchild;
         curr != NULL;
         curr = MemoryContextTraverseNext(curr, context))
    {
        curr->methods->stats(curr, NULL, NULL, consumed, false);
    }
}
 
/*
 * MemoryContextStats
 *      Print statistics about the named context and all its descendants.
 *
 * This is just a debugging utility, so it's not very fancy.  However, we do
 * make some effort to summarize when the output would otherwise be very long.
 * The statistics are sent to stderr.
 */
void
MemoryContextStats(MemoryContext context)
{
    /* Hard-wired limits are usually good enough */
    MemoryContextStatsDetail(context, 100, 100, true);
}
 
/*
 * MemoryContextStatsDetail
 *
 * Entry point for use if you want to vary the number of child contexts shown.
 *
 * If print_to_stderr is true, print statistics about the memory contexts
 * with fprintf(stderr), otherwise use ereport().
 */
void
MemoryContextStatsDetail(MemoryContext context,
                         int max_level, int max_children,
                         bool print_to_stderr)
{
    MemoryContextCounters grand_totals;
 
    memset(&grand_totals, 0, sizeof(grand_totals));
 
    MemoryContextStatsInternal(context, 1, max_level, max_children,
                               &grand_totals, print_to_stderr);
 
    if (print_to_stderr)
        fprintf(stderr,
                "Grand total: %zu bytes in %zu blocks; %zu free (%zu chunks); %zu used\n",
                grand_totals.totalspace, grand_totals.nblocks,
                grand_totals.freespace, grand_totals.freechunks,
                grand_totals.totalspace - grand_totals.freespace);
    else
    {
        /*
         * Use LOG_SERVER_ONLY to prevent the memory contexts from being sent
         * to the connected client.
         *
         * We don't buffer the information about all memory contexts in a
         * backend into StringInfo and log it as one message.  That would
         * require the buffer to be enlarged, risking an OOM as there could be
         * a large number of memory contexts in a backend.  Instead, we log
         * one message per memory context.
         */
        ereport(LOG_SERVER_ONLY,
                (errhidestmt(true),
                 errhidecontext(true),
                 errmsg_internal("Grand total: %zu bytes in %zu blocks; %zu free (%zu chunks); %zu used",
                                 grand_totals.totalspace, grand_totals.nblocks,
                                 grand_totals.freespace, grand_totals.freechunks,
                                 grand_totals.totalspace - grand_totals.freespace)));
    }
}
 
/*
 * MemoryContextStatsInternal
 *      One recursion level for MemoryContextStats
 *
 * Print stats for this context if possible, but in any case accumulate counts
 * into *totals (if not NULL).
 */
static void
MemoryContextStatsInternal(MemoryContext context, int level,
                           int max_level, int max_children,
                           MemoryContextCounters *totals,
                           bool print_to_stderr)
{
    MemoryContext child;
    int         ichild;
 
    Assert(MemoryContextIsValid(context));
 
    /* Examine the context itself */
    context->methods->stats(context,
                            MemoryContextStatsPrint,
                            &level,
                            totals, print_to_stderr);
 
    /*
     * Examine children.
     *
     * If we are past the recursion depth limit or already running low on
     * stack, do not print them explicitly but just summarize them. Similarly,
     * if there are more than max_children of them, we do not print the rest
     * explicitly, but just summarize them.
     */
    child = context->firstchild;
    ichild = 0;
    if (level <= max_level && !stack_is_too_deep())
    {
        for (; child != NULL && ichild < max_children;
             child = child->nextchild, ichild++)
        {
            MemoryContextStatsInternal(child, level + 1,
                                       max_level, max_children,
                                       totals,
                                       print_to_stderr);
        }
    }
 
    if (child != NULL)
    {
        /* Summarize the rest of the children, avoiding recursion. */
        MemoryContextCounters local_totals;
 
        memset(&local_totals, 0, sizeof(local_totals));
 
        ichild = 0;
        while (child != NULL)
        {
            child->methods->stats(child, NULL, NULL, &local_totals, false);
            ichild++;
            child = MemoryContextTraverseNext(child, context);
        }
 
        if (print_to_stderr)
        {
            for (int i = 0; i < level; i++)
                fprintf(stderr, "  ");
            fprintf(stderr,
                    "%d more child contexts containing %zu total in %zu blocks; %zu free (%zu chunks); %zu used\n",
                    ichild,
                    local_totals.totalspace,
                    local_totals.nblocks,
                    local_totals.freespace,
                    local_totals.freechunks,
                    local_totals.totalspace - local_totals.freespace);
        }
        else
            ereport(LOG_SERVER_ONLY,
                    (errhidestmt(true),
                     errhidecontext(true),
                     errmsg_internal("level: %d; %d more child contexts containing %zu total in %zu blocks; %zu free (%zu chunks); %zu used",
                                     level,
                                     ichild,
                                     local_totals.totalspace,
                                     local_totals.nblocks,
                                     local_totals.freespace,
                                     local_totals.freechunks,
                                     local_totals.totalspace - local_totals.freespace)));
 
        if (totals)
        {
            totals->nblocks += local_totals.nblocks;
            totals->freechunks += local_totals.freechunks;
            totals->totalspace += local_totals.totalspace;
            totals->freespace += local_totals.freespace;
        }
    }
}
 
/*
 * MemoryContextStatsPrint
 *      Print callback used by MemoryContextStatsInternal
 *
 * For now, the passthru pointer just points to "int level"; later we might
 * make that more complicated.
 */
static void
MemoryContextStatsPrint(MemoryContext context, void *passthru,
                        const char *stats_string,
                        bool print_to_stderr)
{
    int         level = *(int *) passthru;
    const char *name = context->name;
    const char *ident = context->ident;
    char        truncated_ident[110];
    int         i;
 
    /*
     * It seems preferable to label dynahash contexts with just the hash table
     * name.  Those are already unique enough, so the "dynahash" part isn't
     * very helpful, and this way is more consistent with pre-v11 practice.
     */
    if (ident && strcmp(name, "dynahash") == 0)
    {
        name = ident;
        ident = NULL;
    }
 
    truncated_ident[0] = '\0';
 
    if (ident)
    {
        /*
         * Some contexts may have very long identifiers (e.g., SQL queries).
         * Arbitrarily truncate at 100 bytes, but be careful not to break
         * multibyte characters.  Also, replace ASCII control characters, such
         * as newlines, with spaces.
         */
        int         idlen = strlen(ident);
        bool        truncated = false;
 
        strcpy(truncated_ident, ": ");
        i = strlen(truncated_ident);
 
        if (idlen > 100)
        {
            idlen = pg_mbcliplen(ident, idlen, 100);
            truncated = true;
        }
 
        while (idlen-- > 0)
        {
            unsigned char c = *ident++;
 
            if (c < ' ')
                c = ' ';
            truncated_ident[i++] = c;
        }
        truncated_ident[i] = '\0';
 
        if (truncated)
            strcat(truncated_ident, "...");
    }
 
    if (print_to_stderr)
    {
        for (i = 1; i < level; i++)
            fprintf(stderr, "  ");
        fprintf(stderr, "%s: %s%s\n", name, stats_string, truncated_ident);
    }
    else
        ereport(LOG_SERVER_ONLY,
                (errhidestmt(true),
                 errhidecontext(true),
                 errmsg_internal("level: %d; %s: %s%s",
                                 level, name, stats_string, truncated_ident)));
}
 
/*
 * MemoryContextCheck
 *      Check all chunks in the named context and its children.
 *
 * This is just a debugging utility, so it's not fancy.
 */
#ifdef MEMORY_CONTEXT_CHECKING
void
MemoryContextCheck(MemoryContext context)
{
    Assert(MemoryContextIsValid(context));
    context->methods->check(context);
 
    for (MemoryContext curr = context->firstchild;
         curr != NULL;
         curr = MemoryContextTraverseNext(curr, context))
    {
        Assert(MemoryContextIsValid(curr));
        curr->methods->check(curr);
    }
}
#endif
 
/*
 * MemoryContextCreate
 *      Context-type-independent part of context creation.
 *
 * This is only intended to be called by context-type-specific
 * context creation routines, not by the unwashed masses.
 *
 * The memory context creation procedure goes like this:
 *  1.  Context-type-specific routine makes some initial space allocation,
 *      including enough space for the context header.  If it fails,
 *      it can ereport() with no damage done.
 *  2.  Context-type-specific routine sets up all type-specific fields of
 *      the header (those beyond MemoryContextData proper), as well as any
 *      other management fields it needs to have a fully valid context.
 *      Usually, failure in this step is impossible, but if it's possible
 *      the initial space allocation should be freed before ereport'ing.
 *  3.  Context-type-specific routine calls MemoryContextCreate() to fill in
 *      the generic header fields and link the context into the context tree.
 *  4.  We return to the context-type-specific routine, which finishes
 *      up type-specific initialization.  This routine can now do things
 *      that might fail (like allocate more memory), so long as it's
 *      sure the node is left in a state that delete will handle.
 *
 * node: the as-yet-uninitialized common part of the context header node.
 * tag: NodeTag code identifying the memory context type.
 * method_id: MemoryContextMethodID of the context-type being created.
 * parent: parent context, or NULL if this will be a top-level context.
 * name: name of context (must be statically allocated).
 *
 * Context routines generally assume that MemoryContextCreate can't fail,
 * so this can contain Assert but not elog/ereport.
 */
void
MemoryContextCreate(MemoryContext node,
                    NodeTag tag,
                    MemoryContextMethodID method_id,
                    MemoryContext parent,
                    const char *name)
{
    /* Creating new memory contexts is not allowed in a critical section */
    Assert(CritSectionCount == 0);
 
    /* Validate parent, to help prevent crazy context linkages */
    Assert(parent == NULL || MemoryContextIsValid(parent));
    Assert(node != parent);
 
    /* Initialize all standard fields of memory context header */
    node->type = tag;
    node->isReset = true;
    node->methods = &mcxt_methods[method_id];
    node->parent = parent;
    node->firstchild = NULL;
    node->mem_allocated = 0;
    node->prevchild = NULL;
    node->name = name;
    node->ident = NULL;
    node->reset_cbs = NULL;
 
    /* OK to link node into context tree */
    if (parent)
    {
        node->nextchild = parent->firstchild;
        if (parent->firstchild != NULL)
            parent->firstchild->prevchild = node;
        parent->firstchild = node;
        /* inherit allowInCritSection flag from parent */
        node->allowInCritSection = parent->allowInCritSection;
    }
    else
    {
        node->nextchild = NULL;
        node->allowInCritSection = false;
    }
}
 
/*
 * MemoryContextAllocationFailure
 *      For use by MemoryContextMethods implementations to handle when malloc
 *      returns NULL.  The behavior is specific to whether MCXT_ALLOC_NO_OOM
 *      is in 'flags'.
 */
void *
MemoryContextAllocationFailure(MemoryContext context, Size size, int flags)
{
    if ((flags & MCXT_ALLOC_NO_OOM) == 0)
    {
        if (TopMemoryContext)
            MemoryContextStats(TopMemoryContext);
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory"),
                 errdetail("Failed on request of size %zu in memory context \"%s\".",
                           size, context->name)));
    }
    return NULL;
}
 
/*
 * MemoryContextSizeFailure
 *      For use by MemoryContextMethods implementations to handle invalid
 *      memory allocation request sizes.
 */
void
MemoryContextSizeFailure(MemoryContext context, Size size, int flags)
{
    elog(ERROR, "invalid memory alloc request size %zu", size);
}
 
/*
 * MemoryContextAlloc
 *      Allocate space within the specified context.
 *
 * This could be turned into a macro, but we'd have to import
 * nodes/memnodes.h into postgres.h which seems a bad idea.
 */
void *
MemoryContextAlloc(MemoryContext context, Size size)
{
    void       *ret;
 
    Assert(MemoryContextIsValid(context));
    AssertNotInCriticalSection(context);
 
    context->isReset = false;
 
    /*
     * For efficiency reasons, we purposefully offload the handling of
     * allocation failures to the MemoryContextMethods implementation as this
     * allows these checks to be performed only when an actual malloc needs to
     * be done to request more memory from the OS.  Additionally, not having
     * to execute any instructions after this call allows the compiler to use
     * the sibling call optimization.  If you're considering adding code after
     * this call, consider making it the responsibility of the 'alloc'
     * function instead.
     */
    ret = context->methods->alloc(context, size, 0);
 
    VALGRIND_MEMPOOL_ALLOC(context, ret, size);
 
    return ret;
}
 
/*
 * MemoryContextAllocZero
 *      Like MemoryContextAlloc, but clears allocated memory
 *
 *  We could just call MemoryContextAlloc then clear the memory, but this
 *  is a very common combination, so we provide the combined operation.
 */
void *
MemoryContextAllocZero(MemoryContext context, Size size)
{
    void       *ret;
 
    Assert(MemoryContextIsValid(context));
    AssertNotInCriticalSection(context);
 
    context->isReset = false;
 
    ret = context->methods->alloc(context, size, 0);
 
    VALGRIND_MEMPOOL_ALLOC(context, ret, size);
 
    MemSetAligned(ret, 0, size);
 
    return ret;
}
 
/*
 * MemoryContextAllocExtended
 *      Allocate space within the specified context using the given flags.
 */
void *
MemoryContextAllocExtended(MemoryContext context, Size size, int flags)
{
    void       *ret;
 
    Assert(MemoryContextIsValid(context));
    AssertNotInCriticalSection(context);
 
    if (!((flags & MCXT_ALLOC_HUGE) != 0 ? AllocHugeSizeIsValid(size) :
          AllocSizeIsValid(size)))
        elog(ERROR, "invalid memory alloc request size %zu", size);
 
    context->isReset = false;
 
    ret = context->methods->alloc(context, size, flags);
    if (unlikely(ret == NULL))
        return NULL;
 
    VALGRIND_MEMPOOL_ALLOC(context, ret, size);
 
    if ((flags & MCXT_ALLOC_ZERO) != 0)
        MemSetAligned(ret, 0, size);
 
    return ret;
}
 
/*
 * HandleLogMemoryContextInterrupt
 *      Handle receipt of an interrupt indicating logging of memory
 *      contexts.
 *
 * All the actual work is deferred to ProcessLogMemoryContextInterrupt(),
 * because we cannot safely emit a log message inside the signal handler.
 */
void
HandleLogMemoryContextInterrupt(void)
{
    InterruptPending = true;
    LogMemoryContextPending = true;
    /* latch will be set by procsignal_sigusr1_handler */
}
 
/*
 * ProcessLogMemoryContextInterrupt
 *      Perform logging of memory contexts of this backend process.
 *
 * Any backend that participates in ProcSignal signaling must arrange
 * to call this function if we see LogMemoryContextPending set.
 * It is called from CHECK_FOR_INTERRUPTS(), which is enough because
 * the target process for logging of memory contexts is a backend.
 */
void
ProcessLogMemoryContextInterrupt(void)
{
    LogMemoryContextPending = false;
 
    /*
     * Exit immediately if memory context logging is already in progress. This
     * prevents recursive calls, which could occur if logging is requested
     * repeatedly and rapidly, potentially leading to infinite recursion and a
     * crash.
     */
    if (LogMemoryContextInProgress)
        return;
    LogMemoryContextInProgress = true;
 
    PG_TRY();
    {
        /*
         * Use LOG_SERVER_ONLY to prevent this message from being sent to the
         * connected client.
         */
        ereport(LOG_SERVER_ONLY,
                (errhidestmt(true),
                 errhidecontext(true),
                 errmsg("logging memory contexts of PID %d", MyProcPid)));
 
        /*
         * When a backend process is consuming huge memory, logging all its
         * memory contexts might overrun available disk space. To prevent
         * this, we limit the depth of the hierarchy, as well as the number of
         * child contexts to log per parent to 100.
         *
         * As with MemoryContextStats(), we suppose that practical cases where
         * the dump gets long will typically be huge numbers of siblings under
         * the same parent context; while the additional debugging value from
         * seeing details about individual siblings beyond 100 will not be
         * large.
         */
        MemoryContextStatsDetail(TopMemoryContext, 100, 100, false);
    }
    PG_FINALLY();
    {
        LogMemoryContextInProgress = false;
    }
    PG_END_TRY();
}
 
void *
palloc(Size size)
{
    /* duplicates MemoryContextAlloc to avoid increased overhead */
    void       *ret;
    MemoryContext context = CurrentMemoryContext;
 
    Assert(MemoryContextIsValid(context));
    AssertNotInCriticalSection(context);
 
    context->isReset = false;
 
    /*
     * For efficiency reasons, we purposefully offload the handling of
     * allocation failures to the MemoryContextMethods implementation as this
     * allows these checks to be performed only when an actual malloc needs to
     * be done to request more memory from the OS.  Additionally, not having
     * to execute any instructions after this call allows the compiler to use
     * the sibling call optimization.  If you're considering adding code after
     * this call, consider making it the responsibility of the 'alloc'
     * function instead.
     */
    ret = context->methods->alloc(context, size, 0);
    /* We expect OOM to be handled by the alloc function */
    Assert(ret != NULL);
    VALGRIND_MEMPOOL_ALLOC(context, ret, size);
 
    return ret;
}
 
void *
palloc0(Size size)
{
    /* duplicates MemoryContextAllocZero to avoid increased overhead */
    void       *ret;
    MemoryContext context = CurrentMemoryContext;
 
    Assert(MemoryContextIsValid(context));
    AssertNotInCriticalSection(context);
 
    context->isReset = false;
 
    ret = context->methods->alloc(context, size, 0);
    /* We expect OOM to be handled by the alloc function */
    Assert(ret != NULL);
    VALGRIND_MEMPOOL_ALLOC(context, ret, size);
 
    MemSetAligned(ret, 0, size);
 
    return ret;
}
 
void *
palloc_extended(Size size, int flags)
{
    /* duplicates MemoryContextAllocExtended to avoid increased overhead */
    void       *ret;
    MemoryContext context = CurrentMemoryContext;
 
    Assert(MemoryContextIsValid(context));
    AssertNotInCriticalSection(context);
 
    context->isReset = false;
 
    ret = context->methods->alloc(context, size, flags);
    if (unlikely(ret == NULL))
    {
        /* NULL can be returned only when using MCXT_ALLOC_NO_OOM */
        Assert(flags & MCXT_ALLOC_NO_OOM);
        return NULL;
    }
 
    VALGRIND_MEMPOOL_ALLOC(context, ret, size);
 
    if ((flags & MCXT_ALLOC_ZERO) != 0)
        MemSetAligned(ret, 0, size);
 
    return ret;
}
 
/*
 * MemoryContextAllocAligned
 *      Allocate 'size' bytes of memory in 'context' aligned to 'alignto'
 *      bytes.
 *
 * Currently, we align addresses by requesting additional bytes from the
 * MemoryContext's standard allocator function and then aligning the returned
 * address by the required alignment.  This means that the given MemoryContext
 * must support providing us with a chunk of memory that's larger than 'size'.
 * For allocators such as Slab, that's not going to work, as slab only allows
 * chunks of the size that's specified when the context is created.
 *
 * 'alignto' must be a power of 2.
 * 'flags' may be 0 or set the same as MemoryContextAllocExtended().
 */
void *
MemoryContextAllocAligned(MemoryContext context,
                          Size size, Size alignto, int flags)
{
    MemoryChunk *alignedchunk;
    Size        alloc_size;
    void       *unaligned;
    void       *aligned;
 
    /*
     * Restrict alignto to ensure that it can fit into the "value" field of
     * the redirection MemoryChunk, and that the distance back to the start of
     * the unaligned chunk will fit into the space available for that.  This
     * isn't a limitation in practice, since it wouldn't make much sense to
     * waste that much space.
     */
    Assert(alignto < (128 * 1024 * 1024));
 
    /* ensure alignto is a power of 2 */
    Assert((alignto & (alignto - 1)) == 0);
 
    /*
     * If the alignment requirements are less than what we already guarantee
     * then just use the standard allocation function.
     */
    if (unlikely(alignto <= MAXIMUM_ALIGNOF))
        return MemoryContextAllocExtended(context, size, flags);
 
    /*
     * We implement aligned pointers by simply allocating enough memory for
     * the requested size plus the alignment and an additional "redirection"
     * MemoryChunk.  This additional MemoryChunk is required for operations
     * such as pfree when used on the pointer returned by this function.  We
     * use this redirection MemoryChunk in order to find the pointer to the
     * memory that was returned by the MemoryContextAllocExtended call below.
     * We do that by "borrowing" the block offset field and instead of using
     * that to find the offset into the owning block, we use it to find the
     * original allocated address.
     *
     * Here we must allocate enough extra memory so that we can still align
     * the pointer returned by MemoryContextAllocExtended and also have enough
     * space for the redirection MemoryChunk.  Since allocations will already
     * be at least aligned by MAXIMUM_ALIGNOF, we can subtract that amount
     * from the allocation size to save a little memory.
     */
    alloc_size = size + PallocAlignedExtraBytes(alignto);
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* ensure there's space for a sentinel byte */
    alloc_size += 1;
#endif
 
    /*
     * Perform the actual allocation, but do not pass down MCXT_ALLOC_ZERO.
     * This ensures that wasted bytes beyond the aligned chunk do not become
     * DEFINED.
     */
    unaligned = MemoryContextAllocExtended(context, alloc_size,
                                           flags & ~MCXT_ALLOC_ZERO);
 
    /* compute the aligned pointer */
    aligned = (void *) TYPEALIGN(alignto, (char *) unaligned +
                                 sizeof(MemoryChunk));
 
    alignedchunk = PointerGetMemoryChunk(aligned);
 
    /*
     * We set the redirect MemoryChunk so that the block offset calculation is
     * used to point back to the 'unaligned' allocated chunk.  This allows us
     * to use MemoryChunkGetBlock() to find the unaligned chunk when we need
     * to perform operations such as pfree() and repalloc().
     *
     * We store 'alignto' in the MemoryChunk's 'value' so that we know what
     * the alignment was set to should we ever be asked to realloc this
     * pointer.
     */
    MemoryChunkSetHdrMask(alignedchunk, unaligned, alignto,
                          MCTX_ALIGNED_REDIRECT_ID);
 
    /* double check we produced a correctly aligned pointer */
    Assert((void *) TYPEALIGN(alignto, aligned) == aligned);
 
#ifdef MEMORY_CONTEXT_CHECKING
    alignedchunk->requested_size = size;
    /* set mark to catch clobber of "unused" space */
    set_sentinel(aligned, size);
#endif
 
    /*
     * MemoryContextAllocExtended marked the whole unaligned chunk as a
     * vchunk.  Undo that, instead making just the aligned chunk be a vchunk.
     * This prevents Valgrind from complaining that the vchunk is possibly
     * leaked, since only pointers to the aligned chunk will exist.
     *
     * After these calls, the aligned chunk will be marked UNDEFINED, and all
     * the rest of the unaligned chunk (the redirection chunk header, the
     * padding bytes before it, and any wasted trailing bytes) will be marked
     * NOACCESS, which is what we want.
     */
    VALGRIND_MEMPOOL_FREE(context, unaligned);
    VALGRIND_MEMPOOL_ALLOC(context, aligned, size);
 
    /* Now zero (and make DEFINED) just the aligned chunk, if requested */
    if ((flags & MCXT_ALLOC_ZERO) != 0)
        MemSetAligned(aligned, 0, size);
 
    return aligned;
}
 
/*
 * palloc_aligned
 *      Allocate 'size' bytes returning a pointer that's aligned to the
 *      'alignto' boundary.
 *
 * Currently, we align addresses by requesting additional bytes from the
 * MemoryContext's standard allocator function and then aligning the returned
 * address by the required alignment.  This means that the given MemoryContext
 * must support providing us with a chunk of memory that's larger than 'size'.
 * For allocators such as Slab, that's not going to work, as slab only allows
 * chunks of the size that's specified when the context is created.
 *
 * 'alignto' must be a power of 2.
 * 'flags' may be 0 or set the same as MemoryContextAllocExtended().
 */
void *
palloc_aligned(Size size, Size alignto, int flags)
{
    return MemoryContextAllocAligned(CurrentMemoryContext, size, alignto, flags);
}
 
/*
 * pfree
 *      Release an allocated chunk.
 */
void
pfree(void *pointer)
{
#ifdef USE_VALGRIND
    MemoryContext context = GetMemoryChunkContext(pointer);
#endif
 
    MCXT_METHOD(pointer, free_p) (pointer);
 
    VALGRIND_MEMPOOL_FREE(context, pointer);
}
 
/*
 * repalloc
 *      Adjust the size of a previously allocated chunk.
 */
void *
repalloc(void *pointer, Size size)
{
#if defined(USE_ASSERT_CHECKING) || defined(USE_VALGRIND)
    MemoryContext context = GetMemoryChunkContext(pointer);
#endif
    void       *ret;
 
    AssertNotInCriticalSection(context);
 
    /* isReset must be false already */
    Assert(!context->isReset);
 
    /*
     * For efficiency reasons, we purposefully offload the handling of
     * allocation failures to the MemoryContextMethods implementation as this
     * allows these checks to be performed only when an actual malloc needs to
     * be done to request more memory from the OS.  Additionally, not having
     * to execute any instructions after this call allows the compiler to use
     * the sibling call optimization.  If you're considering adding code after
     * this call, consider making it the responsibility of the 'realloc'
     * function instead.
     */
    ret = MCXT_METHOD(pointer, realloc) (pointer, size, 0);
 
    VALGRIND_MEMPOOL_CHANGE(context, pointer, ret, size);
 
    return ret;
}
 
/*
 * repalloc_extended
 *      Adjust the size of a previously allocated chunk,
 *      with HUGE and NO_OOM options.
 */
void *
repalloc_extended(void *pointer, Size size, int flags)
{
#if defined(USE_ASSERT_CHECKING) || defined(USE_VALGRIND)
    MemoryContext context = GetMemoryChunkContext(pointer);
#endif
    void       *ret;
 
    AssertNotInCriticalSection(context);
 
    /* isReset must be false already */
    Assert(!context->isReset);
 
    /*
     * For efficiency reasons, we purposefully offload the handling of
     * allocation failures to the MemoryContextMethods implementation as this
     * allows these checks to be performed only when an actual malloc needs to
     * be done to request more memory from the OS.  Additionally, not having
     * to execute any instructions after this call allows the compiler to use
     * the sibling call optimization.  If you're considering adding code after
     * this call, consider making it the responsibility of the 'realloc'
     * function instead.
     */
    ret = MCXT_METHOD(pointer, realloc) (pointer, size, flags);
    if (unlikely(ret == NULL))
        return NULL;
 
    VALGRIND_MEMPOOL_CHANGE(context, pointer, ret, size);
 
    return ret;
}
 
/*
 * repalloc0
 *      Adjust the size of a previously allocated chunk and zero out the added
 *      space.
 */
void *
repalloc0(void *pointer, Size oldsize, Size size)
{
    void       *ret;
 
    /* catch wrong argument order */
    if (unlikely(oldsize > size))
        elog(ERROR, "invalid repalloc0 call: oldsize %zu, new size %zu",
             oldsize, size);
 
    ret = repalloc(pointer, size);
    memset((char *) ret + oldsize, 0, (size - oldsize));
    return ret;
}
 
/*
 * MemoryContextAllocHuge
 *      Allocate (possibly-expansive) space within the specified context.
 *
 * See considerations in comment at MaxAllocHugeSize.
 */
void *
MemoryContextAllocHuge(MemoryContext context, Size size)
{
    void       *ret;
 
    Assert(MemoryContextIsValid(context));
    AssertNotInCriticalSection(context);
 
    context->isReset = false;
 
    /*
     * For efficiency reasons, we purposefully offload the handling of
     * allocation failures to the MemoryContextMethods implementation as this
     * allows these checks to be performed only when an actual malloc needs to
     * be done to request more memory from the OS.  Additionally, not having
     * to execute any instructions after this call allows the compiler to use
     * the sibling call optimization.  If you're considering adding code after
     * this call, consider making it the responsibility of the 'alloc'
     * function instead.
     */
    ret = context->methods->alloc(context, size, MCXT_ALLOC_HUGE);
 
    VALGRIND_MEMPOOL_ALLOC(context, ret, size);
 
    return ret;
}
 
/*
 * repalloc_huge
 *      Adjust the size of a previously allocated chunk, permitting a large
 *      value.  The previous allocation need not have been "huge".
 */
void *
repalloc_huge(void *pointer, Size size)
{
    /* this one seems not worth its own implementation */
    return repalloc_extended(pointer, size, MCXT_ALLOC_HUGE);
}
 
/*
 * MemoryContextStrdup
 *      Like strdup(), but allocate from the specified context
 */
char *
MemoryContextStrdup(MemoryContext context, const char *string)
{
    char       *nstr;
    Size        len = strlen(string) + 1;
 
    nstr = (char *) MemoryContextAlloc(context, len);
 
    memcpy(nstr, string, len);
 
    return nstr;
}
 
char *
pstrdup(const char *in)
{
    return MemoryContextStrdup(CurrentMemoryContext, in);
}
 
/*
 * pnstrdup
 *      Like pstrdup(), but append null byte to a
 *      not-necessarily-null-terminated input string.
 */
char *
pnstrdup(const char *in, Size len)
{
    char       *out;
 
    len = strnlen(in, len);
 
    out = palloc(len + 1);
    memcpy(out, in, len);
    out[len] = '\0';
 
    return out;
}
 
/*
 * Make copy of string with all trailing newline characters removed.
 */
char *
pchomp(const char *in)
{
    size_t      n;
 
    n = strlen(in);
    while (n > 0 && in[n - 1] == '\n')
        n--;
    return pnstrdup(in, n);
}

BOGUS_MCTX

#define BOGUS_MCTX

(

id

)

Value:

    [id].free_p = BogusFree, \
    [id].realloc = BogusRealloc, \
    [id].get_chunk_context = BogusGetChunkContext, \
    [id].get_chunk_space = BogusGetChunkSpace

Definition at line 57 of file mcxt.c.

MCXT_METHOD

#define MCXT_METHOD	(		pointer,
			method
	)		mcxt_methods[GetMemoryChunkMethodID(pointer)].method

Definition at line 202 of file mcxt.c.

Function Documentation

BogusFree()

static void BogusFree ( void *  pointer )

static

Definition at line 306 of file mcxt.c.

{
    elog(ERROR, "pfree called with invalid pointer %p (header 0x%016" PRIx64 ")",
         pointer, GetMemoryChunkHeader(pointer));
}

References elog, ERROR, fb(), and GetMemoryChunkHeader().

BogusGetChunkContext()

static MemoryContext BogusGetChunkContext ( void *  pointer )

static

Definition at line 321 of file mcxt.c.

{
    elog(ERROR, "GetMemoryChunkContext called with invalid pointer %p (header 0x%016" PRIx64 ")",
         pointer, GetMemoryChunkHeader(pointer));
    return NULL;                /* keep compiler quiet */
}

References elog, ERROR, fb(), and GetMemoryChunkHeader().

BogusGetChunkSpace()

static Size BogusGetChunkSpace ( void *  pointer )

static

Definition at line 329 of file mcxt.c.

{
    elog(ERROR, "GetMemoryChunkSpace called with invalid pointer %p (header 0x%016" PRIx64 ")",
         pointer, GetMemoryChunkHeader(pointer));
    return 0;                   /* keep compiler quiet */
}

References elog, ERROR, fb(), and GetMemoryChunkHeader().

BogusRealloc()

static void * BogusRealloc ( void *  pointer, Size  size, int  flags  )

static

Definition at line 313 of file mcxt.c.

{
    elog(ERROR, "repalloc called with invalid pointer %p (header 0x%016" PRIx64 ")",
         pointer, GetMemoryChunkHeader(pointer));
    return NULL;                /* keep compiler quiet */
}

References elog, ERROR, fb(), and GetMemoryChunkHeader().

GetMemoryChunkContext()

MemoryContext GetMemoryChunkContext

(

void *

pointer

)

Definition at line 756 of file mcxt.c.

{
    return MCXT_METHOD(pointer, get_chunk_context) (pointer);
}

References MCXT_METHOD.

Referenced by AlignedAllocFree(), AlignedAllocGetChunkContext(), AlignedAllocRealloc(), create_unique_paths(), enlarge_list(), execute_dml_stmt(), guc_free(), guc_realloc(), list_delete_first_n(), list_delete_nth_cell(), mark_dummy_rel(), pfree(), repalloc(), repalloc_extended(), reparameterize_path_by_child(), SetPlannerGlobalExtensionState(), and SetRelOptInfoExtensionState().

GetMemoryChunkHeader()

static uint64 GetMemoryChunkHeader ( const void *  pointer )

inlinestatic

Definition at line 240 of file mcxt.c.

{
    uint64      header;
 
    /* Allow access to the uint64 header */
    VALGRIND_MAKE_MEM_DEFINED((char *) pointer - sizeof(uint64), sizeof(uint64));
 
    header = *((const uint64 *) ((const char *) pointer - sizeof(uint64)));
 
    /* Disallow access to the uint64 header */
    VALGRIND_MAKE_MEM_NOACCESS((char *) pointer - sizeof(uint64), sizeof(uint64));
 
    return header;
}

References VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by BogusFree(), BogusGetChunkContext(), BogusGetChunkSpace(), and BogusRealloc().

GetMemoryChunkMethodID()

static MemoryContextMethodID GetMemoryChunkMethodID ( const void *  pointer )

inlinestatic

Definition at line 211 of file mcxt.c.

{
    uint64      header;
 
    /*
     * Try to detect bogus pointers handed to us, poorly though we can.
     * Presumably, a pointer that isn't MAXALIGNED isn't pointing at an
     * allocated chunk.
     */
    Assert(pointer == (const void *) MAXALIGN(pointer));
 
    /* Allow access to the uint64 header */
    VALGRIND_MAKE_MEM_DEFINED((char *) pointer - sizeof(uint64), sizeof(uint64));
 
    header = *((const uint64 *) ((const char *) pointer - sizeof(uint64)));
 
    /* Disallow access to the uint64 header */
    VALGRIND_MAKE_MEM_NOACCESS((char *) pointer - sizeof(uint64), sizeof(uint64));
 
    return (MemoryContextMethodID) (header & MEMORY_CONTEXT_METHODID_MASK);
}

References Assert, MAXALIGN, MEMORY_CONTEXT_METHODID_MASK, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

GetMemoryChunkSpace()

Size GetMemoryChunkSpace

(

void *

pointer

)

Definition at line 770 of file mcxt.c.

{
    return MCXT_METHOD(pointer, get_chunk_space) (pointer);
}

References MCXT_METHOD.

Referenced by AlignedAllocGetChunkSpace(), AlignedAllocRealloc(), copytup_heap(), free_sort_tuple(), getDatumCopy(), ginAllocEntryAccumulator(), ginCombineData(), ginInsertBAEntry(), grow_memtuples(), grow_memtuples(), inittapestate(), intset_create(), intset_new_internal_node(), intset_new_leaf_node(), mergeruns(), tuplesort_begin_batch(), tuplesort_putbrintuple(), tuplesort_putgintuple(), tuplesort_putheaptuple(), tuplesort_putindextuplevalues(), tuplesort_puttupleslot(), tuplestore_begin_common(), tuplestore_clear(), tuplestore_puttupleslot(), tuplestore_putvalues(), tuplestore_trim(), and writetup_heap().

HandleLogMemoryContextInterrupt()

void HandleLogMemoryContextInterrupt

(

void

)

Definition at line 1323 of file mcxt.c.

{
    InterruptPending = true;
    LogMemoryContextPending = true;
    /* latch will be set by procsignal_sigusr1_handler */
}

References InterruptPending, and LogMemoryContextPending.

Referenced by procsignal_sigusr1_handler().

MemoryContextAlloc()

void * MemoryContextAlloc	(	MemoryContext	context,
		Size	size
	)

Definition at line 1232 of file mcxt.c.

{
    void       *ret;
 
    Assert(MemoryContextIsValid(context));
    AssertNotInCriticalSection(context);
 
    context->isReset = false;
 
    /*
     * For efficiency reasons, we purposefully offload the handling of
     * allocation failures to the MemoryContextMethods implementation as this
     * allows these checks to be performed only when an actual malloc needs to
     * be done to request more memory from the OS.  Additionally, not having
     * to execute any instructions after this call allows the compiler to use
     * the sibling call optimization.  If you're considering adding code after
     * this call, consider making it the responsibility of the 'alloc'
     * function instead.
     */
    ret = context->methods->alloc(context, size, 0);
 
    VALGRIND_MEMPOOL_ALLOC(context, ret, size);
 
    return ret;
}

References MemoryContextMethods::alloc, Assert, AssertNotInCriticalSection, MemoryContextData::isReset, MemoryContextIsValid, MemoryContextData::methods, and VALGRIND_MEMPOOL_ALLOC.

Referenced by _bt_getroot(), _bt_getrootheight(), _bt_metaversion(), _bt_preprocess_keys(), _fdvec_resize(), _hash_getcachedmetap(), AddInvalidationMessage(), afterTriggerAddEvent(), AfterTriggerBeginSubXact(), AfterTriggerEnlargeQueryState(), allocate_record_info(), array_agg_deserialize(), array_agg_serialize(), array_fill_internal(), array_in(), array_out(), array_position_common(), array_positions(), array_recv(), array_send(), array_to_text_internal(), Async_Notify(), AtSubCommit_childXids(), BackgroundWorkerMain(), be_tls_open_server(), bt_check_level_from_leftmost(), build_concat_foutcache(), build_dummy_expanded_header(), check_foreign_key(), check_primary_key(), compute_array_stats(), copy_byval_expanded_array(), copyScalarSubstructure(), CopySnapshot(), create_drop_transactional_internal(), dblink_init(), deconstruct_expanded_record(), dense_alloc(), domain_state_setup(), dsm_create_descriptor(), dsm_impl_sysv(), enlarge_list(), EventTriggerBeginCompleteQuery(), ExecHashBuildSkewHash(), ExecHashSkewTableInsert(), ExecParallelRetrieveJitInstrumentation(), ExecSetSlotDescriptor(), expand_array(), fetch_array_arg_replace_nulls(), gbt_enum_sortsupport(), get_attribute_options(), get_multirange_io_data(), get_range_io_data(), get_tablespace(), GetComboCommandId(), GetExplainExtensionId(), GetFdwRoutineForRelation(), GetLockConflicts(), GetPlannerExtensionId(), gtrgm_consistent(), gtrgm_distance(), gtrgm_penalty(), hash_create(), hash_record(), hash_record_extended(), hstore_from_record(), hstore_populate_record(), init_execution_state(), initArrayResultAny(), initArrayResultWithSize(), initBloomState(), initialize_reloptions(), InitializeClientEncoding(), InitializeParallelDSM(), InitPgFdwOptions(), InitXLogInsert(), insertStatEntry(), intset_new_internal_node(), intset_new_leaf_node(), inv_open(), libpqsrv_PGresultSetParent(), list_delete_first_n(), list_delete_nth_cell(), llvm_compile_module(), load_domaintype_info(), load_relcache_init_file(), LockAcquireExtended(), logical_rewrite_log_mapping(), lookup_ts_config_cache(), lookup_type_cache(), make_expanded_record_from_exprecord(), make_expanded_record_from_tupdesc(), make_expanded_record_from_typeid(), makeBoolAggState(), MemoryContextStrdup(), mergeruns(), mXactCachePut(), on_dsm_detach(), packGraph(), pg_column_compression(), pg_column_size(), pg_column_toast_chunk_id(), pg_input_is_valid_common(), pg_snapshot_xip(), pg_stat_get_backend_idset(), pgstat_build_snapshot(), pgstat_fetch_entry(), pgstat_get_entry_ref_cached(), pgstat_get_xact_stack_level(), pgstat_init_snapshot_fixed(), pgstat_read_current_status(), plpgsql_create_econtext(), plpgsql_start_datums(), PLy_push_execution_context(), PLy_subtransaction_enter(), PortalSetResultFormat(), pq_init(), PreCommit_Notify(), PrepareClientEncoding(), PrepareSortSupportComparisonShim(), PrepareTempTablespaces(), PushActiveSnapshotWithLevel(), pushJsonbValueScalar(), pushState(), px_find_digest(), queue_listen(), record_cmp(), record_eq(), record_image_cmp(), record_image_eq(), record_in(), record_out(), record_recv(), record_send(), RegisterExprContextCallback(), RegisterExtensionExplainOption(), RegisterResourceReleaseCallback(), RegisterSubXactCallback(), RegisterXactCallback(), RelationBuildRuleLock(), RelationCacheInitialize(), RelationCreateStorage(), RelationDropStorage(), RelationParseRelOptions(), ReorderBufferAllocate(), ReorderBufferAllocChange(), ReorderBufferAllocRelids(), ReorderBufferAllocTupleBuf(), ReorderBufferAllocTXN(), ReorderBufferRestoreChange(), ReorderBufferSerializeReserve(), RequestNamedLWLockTranche(), RestoreSnapshot(), RT_ALLOC_LEAF(), RT_ALLOC_NODE(), setup_background_workers(), shm_mq_receive(), SnapBuildPurgeOlderTxn(), SPI_connect_ext(), SPI_palloc(), sql_compile_callback(), StoreIndexTuple(), sts_read_tuple(), tbm_begin_private_iterate(), test_enc_conversion(), tstoreStartupReceiver(), tts_virtual_materialize(), tuplesort_readtup_alloc(), and xactGetCommittedInvalidationMessages().

MemoryContextAllocAligned()

void * MemoryContextAllocAligned	(	MemoryContext	context,
		Size	size,
		Size	alignto,
		int	flags
	)

Definition at line 1482 of file mcxt.c.

{
    MemoryChunk *alignedchunk;
    Size        alloc_size;
    void       *unaligned;
    void       *aligned;
 
    /*
     * Restrict alignto to ensure that it can fit into the "value" field of
     * the redirection MemoryChunk, and that the distance back to the start of
     * the unaligned chunk will fit into the space available for that.  This
     * isn't a limitation in practice, since it wouldn't make much sense to
     * waste that much space.
     */
    Assert(alignto < (128 * 1024 * 1024));
 
    /* ensure alignto is a power of 2 */
    Assert((alignto & (alignto - 1)) == 0);
 
    /*
     * If the alignment requirements are less than what we already guarantee
     * then just use the standard allocation function.
     */
    if (unlikely(alignto <= MAXIMUM_ALIGNOF))
        return MemoryContextAllocExtended(context, size, flags);
 
    /*
     * We implement aligned pointers by simply allocating enough memory for
     * the requested size plus the alignment and an additional "redirection"
     * MemoryChunk.  This additional MemoryChunk is required for operations
     * such as pfree when used on the pointer returned by this function.  We
     * use this redirection MemoryChunk in order to find the pointer to the
     * memory that was returned by the MemoryContextAllocExtended call below.
     * We do that by "borrowing" the block offset field and instead of using
     * that to find the offset into the owning block, we use it to find the
     * original allocated address.
     *
     * Here we must allocate enough extra memory so that we can still align
     * the pointer returned by MemoryContextAllocExtended and also have enough
     * space for the redirection MemoryChunk.  Since allocations will already
     * be at least aligned by MAXIMUM_ALIGNOF, we can subtract that amount
     * from the allocation size to save a little memory.
     */
    alloc_size = size + PallocAlignedExtraBytes(alignto);
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* ensure there's space for a sentinel byte */
    alloc_size += 1;
#endif
 
    /*
     * Perform the actual allocation, but do not pass down MCXT_ALLOC_ZERO.
     * This ensures that wasted bytes beyond the aligned chunk do not become
     * DEFINED.
     */
    unaligned = MemoryContextAllocExtended(context, alloc_size,
                                           flags & ~MCXT_ALLOC_ZERO);
 
    /* compute the aligned pointer */
    aligned = (void *) TYPEALIGN(alignto, (char *) unaligned +
                                 sizeof(MemoryChunk));
 
    alignedchunk = PointerGetMemoryChunk(aligned);
 
    /*
     * We set the redirect MemoryChunk so that the block offset calculation is
     * used to point back to the 'unaligned' allocated chunk.  This allows us
     * to use MemoryChunkGetBlock() to find the unaligned chunk when we need
     * to perform operations such as pfree() and repalloc().
     *
     * We store 'alignto' in the MemoryChunk's 'value' so that we know what
     * the alignment was set to should we ever be asked to realloc this
     * pointer.
     */
    MemoryChunkSetHdrMask(alignedchunk, unaligned, alignto,
                          MCTX_ALIGNED_REDIRECT_ID);
 
    /* double check we produced a correctly aligned pointer */
    Assert((void *) TYPEALIGN(alignto, aligned) == aligned);
 
#ifdef MEMORY_CONTEXT_CHECKING
    alignedchunk->requested_size = size;
    /* set mark to catch clobber of "unused" space */
    set_sentinel(aligned, size);
#endif
 
    /*
     * MemoryContextAllocExtended marked the whole unaligned chunk as a
     * vchunk.  Undo that, instead making just the aligned chunk be a vchunk.
     * This prevents Valgrind from complaining that the vchunk is possibly
     * leaked, since only pointers to the aligned chunk will exist.
     *
     * After these calls, the aligned chunk will be marked UNDEFINED, and all
     * the rest of the unaligned chunk (the redirection chunk header, the
     * padding bytes before it, and any wasted trailing bytes) will be marked
     * NOACCESS, which is what we want.
     */
    VALGRIND_MEMPOOL_FREE(context, unaligned);
    VALGRIND_MEMPOOL_ALLOC(context, aligned, size);
 
    /* Now zero (and make DEFINED) just the aligned chunk, if requested */
    if ((flags & MCXT_ALLOC_ZERO) != 0)
        MemSetAligned(aligned, 0, size);
 
    return aligned;
}

References Assert, fb(), MCTX_ALIGNED_REDIRECT_ID, MCXT_ALLOC_ZERO, MemoryChunkSetHdrMask(), MemoryContextAllocExtended(), MemSetAligned, PallocAlignedExtraBytes, PointerGetMemoryChunk, TYPEALIGN, unlikely, VALGRIND_MEMPOOL_ALLOC, and VALGRIND_MEMPOOL_FREE.

Referenced by AlignedAllocRealloc(), GetLocalBufferStorage(), PageSetChecksumCopy(), palloc_aligned(), and smgr_bulk_get_buf().

MemoryContextAllocationFailure()

void * MemoryContextAllocationFailure	(	MemoryContext	context,
		Size	size,
		int	flags
	)

Definition at line 1198 of file mcxt.c.

{
    if ((flags & MCXT_ALLOC_NO_OOM) == 0)
    {
        if (TopMemoryContext)
            MemoryContextStats(TopMemoryContext);
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory"),
                 errdetail("Failed on request of size %zu in memory context \"%s\".",
                           size, context->name)));
    }
    return NULL;
}

References ereport, errcode(), errdetail(), errmsg(), ERROR, fb(), MCXT_ALLOC_NO_OOM, MemoryContextStats(), MemoryContextData::name, and TopMemoryContext.

Referenced by AlignedAllocRealloc(), AllocSetAllocFromNewBlock(), AllocSetAllocLarge(), AllocSetRealloc(), BumpAllocFromNewBlock(), BumpAllocLarge(), GenerationAllocFromNewBlock(), GenerationAllocLarge(), GenerationRealloc(), and SlabAllocFromNewBlock().

MemoryContextAllocExtended()

void * MemoryContextAllocExtended	(	MemoryContext	context,
		Size	size,
		int	flags
	)

Definition at line 1289 of file mcxt.c.

{
    void       *ret;
 
    Assert(MemoryContextIsValid(context));
    AssertNotInCriticalSection(context);
 
    if (!((flags & MCXT_ALLOC_HUGE) != 0 ? AllocHugeSizeIsValid(size) :
          AllocSizeIsValid(size)))
        elog(ERROR, "invalid memory alloc request size %zu", size);
 
    context->isReset = false;
 
    ret = context->methods->alloc(context, size, flags);
    if (unlikely(ret == NULL))
        return NULL;
 
    VALGRIND_MEMPOOL_ALLOC(context, ret, size);
 
    if ((flags & MCXT_ALLOC_ZERO) != 0)
        MemSetAligned(ret, 0, size);
 
    return ret;
}

References MemoryContextMethods::alloc, AllocHugeSizeIsValid, AllocSizeIsValid, Assert, AssertNotInCriticalSection, elog, ERROR, fb(), MemoryContextData::isReset, MCXT_ALLOC_HUGE, MCXT_ALLOC_ZERO, MemoryContextIsValid, MemSetAligned, MemoryContextData::methods, unlikely, and VALGRIND_MEMPOOL_ALLOC.

Referenced by BackgroundWorkerStateChange(), DynaHashAlloc(), guc_malloc(), guc_realloc(), libpqsrv_PQwrap(), MemoryContextAllocAligned(), pagetable_allocate(), and RegisterBackgroundWorker().

MemoryContextAllocHuge()

void * MemoryContextAllocHuge	(	MemoryContext	context,
		Size	size
	)

Definition at line 1725 of file mcxt.c.

{
    void       *ret;
 
    Assert(MemoryContextIsValid(context));
    AssertNotInCriticalSection(context);
 
    context->isReset = false;
 
    /*
     * For efficiency reasons, we purposefully offload the handling of
     * allocation failures to the MemoryContextMethods implementation as this
     * allows these checks to be performed only when an actual malloc needs to
     * be done to request more memory from the OS.  Additionally, not having
     * to execute any instructions after this call allows the compiler to use
     * the sibling call optimization.  If you're considering adding code after
     * this call, consider making it the responsibility of the 'alloc'
     * function instead.
     */
    ret = context->methods->alloc(context, size, MCXT_ALLOC_HUGE);
 
    VALGRIND_MEMPOOL_ALLOC(context, ret, size);
 
    return ret;
}

References MemoryContextMethods::alloc, Assert, AssertNotInCriticalSection, MemoryContextData::isReset, MCXT_ALLOC_HUGE, MemoryContextIsValid, MemoryContextData::methods, and VALGRIND_MEMPOOL_ALLOC.

Referenced by perform_default_encoding_conversion(), pg_buffercache_os_pages_internal(), pg_buffercache_pages(), pg_do_encoding_conversion(), and pgstat_read_current_status().

MemoryContextAllocZero()

void * MemoryContextAllocZero	(	MemoryContext	context,
		Size	size
	)

Definition at line 1266 of file mcxt.c.

{
    void       *ret;
 
    Assert(MemoryContextIsValid(context));
    AssertNotInCriticalSection(context);
 
    context->isReset = false;
 
    ret = context->methods->alloc(context, size, 0);
 
    VALGRIND_MEMPOOL_ALLOC(context, ret, size);
 
    MemSetAligned(ret, 0, size);
 
    return ret;
}

References MemoryContextMethods::alloc, Assert, AssertNotInCriticalSection, MemoryContextData::isReset, MemoryContextIsValid, MemSetAligned, MemoryContextData::methods, and VALGRIND_MEMPOOL_ALLOC.

Referenced by add_tabstat_xact_level(), AllocateAttribute(), array_set_element_expanded(), array_sort_internal(), AttrDefaultFetch(), cached_function_compile(), CheckNNConstraintFetch(), ClientAuthentication(), create_pg_locale_builtin(), create_pg_locale_icu(), create_pg_locale_libc(), CreatePortal(), CreateWaitEventSet(), DCH_cache_getnew(), ensure_record_cache_typmod_slot_exists(), ExecHashBuildSkewHash(), ExecParallelRetrieveJitInstrumentation(), expandColorTrigrams(), fmgr_security_definer(), gistAllocateNewPageBuffer(), index_form_tuple_context(), init_MultiFuncCall(), init_sql_fcache(), initArrayResultArr(), InitializeSession(), InitWalSender(), InitXLogInsert(), json_populate_type(), jsonb_agg_transfn_worker(), jsonb_object_agg_transfn_worker(), llvm_create_context(), load_relcache_init_file(), LookupOpclassInfo(), make_expanded_record_from_datum(), newLOfd(), NUM_cache_getnew(), pg_decode_begin_prepare_txn(), pg_decode_begin_txn(), pg_decode_stream_start(), pgoutput_begin_txn(), pgstat_prep_pending_entry(), pgstat_register_kind(), PLy_exec_function(), PLy_function_save_args(), PLy_input_setup_func(), PLy_input_setup_tuple(), PLy_output_setup_func(), PLy_output_setup_tuple(), populate_record_worker(), populate_recordset_worker(), prepare_column_cache(), PrepareInvalidationState(), push_old_value(), PushTransaction(), px_find_cipher(), RehashCatCache(), RehashCatCacheLists(), RelationBuildPartitionDesc(), RelationBuildPartitionKey(), RelationBuildRowSecurity(), RelationBuildTupleDesc(), RelationInitIndexAccessInfo(), ReorderBufferCopySnap(), ReorderBufferIterTXNInit(), ReorderBufferRestoreChange(), ResourceOwnerCreate(), ResourceOwnerEnlarge(), satisfies_hash_partition(), SearchCatCacheList(), secure_open_gssapi(), SetConstraintStateCreate(), SetPlannerGlobalExtensionState(), SetPlannerInfoExtensionState(), SetRelOptInfoExtensionState(), SnapBuildBuildSnapshot(), SnapBuildRestoreSnapshot(), spgGetCache(), sts_puttuple(), ts_accum(), ts_stat_sql(), and WinGetPartitionLocalMemory().

MemoryContextAllowInCriticalSection()

void MemoryContextAllowInCriticalSection	(	MemoryContext	context,
		bool	allow
	)

Definition at line 743 of file mcxt.c.

{
    Assert(MemoryContextIsValid(context));
 
    context->allowInCritSection = allow;
}

References MemoryContextData::allowInCritSection, Assert, fb(), and MemoryContextIsValid.

Referenced by InitSync(), MemoryContextInit(), and XLOGShmemInit().

MemoryContextCallResetCallbacks()

static void MemoryContextCallResetCallbacks ( MemoryContext  context )

static

Definition at line 634 of file mcxt.c.

{
    MemoryContextCallback *cb;
 
    /*
     * We pop each callback from the list before calling.  That way, if an
     * error occurs inside the callback, we won't try to call it a second time
     * in the likely event that we reset or delete the context later.
     */
    while ((cb = context->reset_cbs) != NULL)
    {
        context->reset_cbs = cb->next;
        cb->func(cb->arg);
    }
}

References MemoryContextCallback::arg, fb(), MemoryContextCallback::func, MemoryContextCallback::next, and MemoryContextData::reset_cbs.

Referenced by MemoryContextDeleteOnly(), and MemoryContextResetOnly().

MemoryContextCreate()

void MemoryContextCreate	(	MemoryContext	node,
		NodeTag	tag,
		MemoryContextMethodID	method_id,
		MemoryContext	parent,
		const char *	name
	)

Definition at line 1149 of file mcxt.c.

{
    /* Creating new memory contexts is not allowed in a critical section */
    Assert(CritSectionCount == 0);
 
    /* Validate parent, to help prevent crazy context linkages */
    Assert(parent == NULL || MemoryContextIsValid(parent));
    Assert(node != parent);
 
    /* Initialize all standard fields of memory context header */
    node->type = tag;
    node->isReset = true;
    node->methods = &mcxt_methods[method_id];
    node->parent = parent;
    node->firstchild = NULL;
    node->mem_allocated = 0;
    node->prevchild = NULL;
    node->name = name;
    node->ident = NULL;
    node->reset_cbs = NULL;
 
    /* OK to link node into context tree */
    if (parent)
    {
        node->nextchild = parent->firstchild;
        if (parent->firstchild != NULL)
            parent->firstchild->prevchild = node;
        parent->firstchild = node;
        /* inherit allowInCritSection flag from parent */
        node->allowInCritSection = parent->allowInCritSection;
    }
    else
    {
        node->nextchild = NULL;
        node->allowInCritSection = false;
    }
}

References MemoryContextData::allowInCritSection, Assert, CritSectionCount, fb(), MemoryContextData::firstchild, MemoryContextData::ident, MemoryContextData::isReset, mcxt_methods, MemoryContextData::mem_allocated, MemoryContextIsValid, MemoryContextData::methods, name, MemoryContextData::name, MemoryContextData::nextchild, MemoryContextData::parent, MemoryContextData::prevchild, and MemoryContextData::reset_cbs.

Referenced by AllocSetContextCreateInternal(), BumpContextCreate(), GenerationContextCreate(), and SlabContextCreate().

MemoryContextDelete()

void MemoryContextDelete

(

MemoryContext

context

)

Definition at line 472 of file mcxt.c.

{
    MemoryContext curr;
 
    Assert(MemoryContextIsValid(context));
 
    /*
     * Delete subcontexts from the bottom up.
     *
     * Note: Do not use recursion here.  A "stack depth limit exceeded" error
     * would be unpleasant if we're already in the process of cleaning up from
     * transaction abort.  We also cannot use MemoryContextTraverseNext() here
     * because we modify the tree as we go.
     */
    curr = context;
    for (;;)
    {
        MemoryContext parent;
 
        /* Descend down until we find a leaf context with no children */
        while (curr->firstchild != NULL)
            curr = curr->firstchild;
 
        /*
         * We're now at a leaf with no children. Free it and continue from the
         * parent.  Or if this was the original node, we're all done.
         */
        parent = curr->parent;
        MemoryContextDeleteOnly(curr);
 
        if (curr == context)
            break;
        curr = parent;
    }
}

References Assert, fb(), MemoryContextData::firstchild, MemoryContextDeleteOnly(), MemoryContextIsValid, and MemoryContextData::parent.

Referenced by _brin_parallel_merge(), AfterTriggerEndXact(), afterTriggerInvokeEvents(), ApplyLauncherMain(), AtEOSubXact_SPI(), AtEOXact_LargeObject(), AtSubCleanup_Memory(), AtSubCommit_Memory(), AttachPartitionEnsureIndexes(), AutoVacLauncherMain(), autovacuum_do_vac_analyze(), AutoVacWorkerMain(), AuxiliaryProcessMainCommon(), BackgroundWorkerMain(), blbuild(), blinsert(), brin_free_desc(), brin_minmax_multi_union(), bringetbitmap(), brininsert(), bt_check_every_level(), btendscan(), btree_xlog_cleanup(), btvacuumscan(), BuildParamLogString(), BuildRelationExtStatistics(), CloneRowTriggersToPartition(), cluster(), compactify_ranges(), compile_plperl_function(), compile_pltcl_function(), compute_expr_stats(), compute_index_stats(), ComputeExtStatisticsRows(), createTrgmNFA(), CreateTriggerFiringOn(), daitch_mokotoff(), decr_dcc_refcount(), DeleteExpandedObject(), DiscreteKnapsack(), do_analyze_rel(), do_start_worker(), DoCopyTo(), DropCachedPlan(), each_worker(), each_worker_jsonb(), elements_worker(), elements_worker_jsonb(), end_heap_rewrite(), EndCopy(), EndCopyFrom(), ensure_free_space_in_buffer(), EventTriggerEndCompleteQuery(), EventTriggerInvoke(), exec_simple_query(), ExecEndAgg(), ExecEndMemoize(), ExecEndRecursiveUnion(), ExecEndSetOp(), ExecEndWindowAgg(), ExecHashTableDestroy(), execute_sql_string(), ExecVacuum(), file_acquire_sample_rows(), fill_hba_view(), fill_ident_view(), free_auth_file(), free_plperl_function(), FreeCachedExpression(), FreeDecodingContext(), FreeExecutorState(), FreeExprContext(), freeGISTstate(), FreeSnapshotBuilder(), geqo_eval(), get_actual_variable_range(), get_rel_sync_entry(), GetWALRecordsInfo(), GetXLogSummaryStats(), gin_check_parent_keys_consistency(), gin_check_posting_tree_parent_keys_consistency(), gin_xlog_cleanup(), ginbuild(), ginbulkdelete(), ginendscan(), gininsert(), ginInsertCleanup(), ginPlaceToPage(), gist_xlog_cleanup(), gistbuild(), gistvacuumscan(), hash_destroy(), inline_function(), inline_function_in_from(), libpqrcv_processTuples(), load_hba(), load_ident(), load_tzoffsets(), makeArrayResultArr(), makeMdArrayResult(), materializeQueryResult(), MemoryContextDeleteChildren(), NIFinishBuild(), pg_backup_stop(), pg_decode_shutdown(), pg_get_wal_block_info(), pgstat_clear_backend_activity_snapshot(), pgstat_clear_snapshot(), plperl_spi_freeplan(), plperl_spi_prepare(), plpgsql_free_function_memory(), pltcl_handler(), pltcl_SPI_prepare(), PLy_cursor_dealloc(), PLy_cursor_plan(), PLy_plan_dealloc(), PLy_pop_execution_context(), PLy_procedure_delete(), PLy_spi_execute_fetch_result(), PLy_spi_execute_plan(), PortalDrop(), PostgresMain(), postquel_end(), prepare_next_query(), printtup_shutdown(), ProcessConfigFile(), publicationListToArray(), RE_compile_and_cache(), rebuild_database_list(), ReindexMultipleTables(), ReindexPartitions(), ReindexRelationConcurrently(), RelationBuildDesc(), RelationBuildRuleLock(), RelationDestroyRelation(), ReleaseCachedPlan(), ReorderBufferFree(), ResetUnloggedRelations(), RevalidateCachedQuery(), serializeAnalyzeShutdown(), shdepReassignOwned(), shutdown_MultiFuncCall(), spg_xlog_cleanup(), spgbuild(), spgendscan(), spginsert(), SPI_finish(), SPI_freeplan(), SPI_freetuptable(), sql_delete_callback(), statext_dependencies_build(), strlist_to_textarray(), SysLoggerMain(), test_pattern(), TidStoreDestroy(), tokenize_auth_file(), tuplesort_end(), tuplestore_end(), union_tuples(), UploadManifest(), and validateForeignKeyConstraint().

MemoryContextDeleteChildren()

void MemoryContextDeleteChildren

(

MemoryContext

context

)

Definition at line 555 of file mcxt.c.

{
    Assert(MemoryContextIsValid(context));
 
    /*
     * MemoryContextDelete will delink the child from me, so just iterate as
     * long as there is a child.
     */
    while (context->firstchild != NULL)
        MemoryContextDelete(context->firstchild);
}

References Assert, fb(), MemoryContextData::firstchild, MemoryContextDelete(), and MemoryContextIsValid.

Referenced by AtAbort_Portals(), AtSubAbort_Portals(), exec_stmt_block(), MemoryContextReset(), PersistHoldablePortal(), PortalRunMulti(), and RelationCloseCleanup().

MemoryContextDeleteOnly()

static void MemoryContextDeleteOnly ( MemoryContext  context )

static

Definition at line 514 of file mcxt.c.

{
    Assert(MemoryContextIsValid(context));
    /* We had better not be deleting TopMemoryContext ... */
    Assert(context != TopMemoryContext);
    /* And not CurrentMemoryContext, either */
    Assert(context != CurrentMemoryContext);
    /* All the children should've been deleted already */
    Assert(context->firstchild == NULL);
 
    /*
     * It's not entirely clear whether 'tis better to do this before or after
     * delinking the context; but an error in a callback will likely result in
     * leaking the whole context (if it's not a root context) if we do it
     * after, so let's do it before.
     */
    MemoryContextCallResetCallbacks(context);
 
    /*
     * We delink the context from its parent before deleting it, so that if
     * there's an error we won't have deleted/busted contexts still attached
     * to the context tree.  Better a leak than a crash.
     */
    MemoryContextSetParent(context, NULL);
 
    /*
     * Also reset the context's ident pointer, in case it points into the
     * context.  This would only matter if someone tries to get stats on the
     * (already unlinked) context, which is unlikely, but let's be safe.
     */
    context->ident = NULL;
 
    context->methods->delete_context(context);
}

References Assert, CurrentMemoryContext, MemoryContextMethods::delete_context, fb(), MemoryContextData::firstchild, MemoryContextData::ident, MemoryContextCallResetCallbacks(), MemoryContextIsValid, MemoryContextSetParent(), MemoryContextData::methods, and TopMemoryContext.

Referenced by MemoryContextDelete().

MemoryContextGetParent()

MemoryContext MemoryContextGetParent

(

MemoryContext

context

)

Definition at line 780 of file mcxt.c.

{
    Assert(MemoryContextIsValid(context));
 
    return context->parent;
}

References Assert, MemoryContextIsValid, and MemoryContextData::parent.

Referenced by advance_windowaggregate(), advance_windowaggregate_base(), ExecAggCopyTransValue(), GetCachedPlan(), pop_stmt_mcontext(), and push_stmt_mcontext().

MemoryContextInit()

void MemoryContextInit

(

void

)

Definition at line 359 of file mcxt.c.

{
    Assert(TopMemoryContext == NULL);
 
    /*
     * First, initialize TopMemoryContext, which is the parent of all others.
     */
    TopMemoryContext = AllocSetContextCreate((MemoryContext) NULL,
                                             "TopMemoryContext",
                                             ALLOCSET_DEFAULT_SIZES);
 
    /*
     * Not having any other place to point CurrentMemoryContext, make it point
     * to TopMemoryContext.  Caller should change this soon!
     */
    CurrentMemoryContext = TopMemoryContext;
 
    /*
     * Initialize ErrorContext as an AllocSetContext with slow growth rate ---
     * we don't really expect much to be allocated in it. More to the point,
     * require it to contain at least 8K at all times. This is the only case
     * where retained memory in a context is *essential* --- we want to be
     * sure ErrorContext still has some memory even if we've run out
     * elsewhere! Also, allow allocations in ErrorContext within a critical
     * section. Otherwise a PANIC will cause an assertion failure in the error
     * reporting code, before printing out the real cause of the failure.
     *
     * This should be the last step in this function, as elog.c assumes memory
     * management works once ErrorContext is non-null.
     */
    ErrorContext = AllocSetContextCreate(TopMemoryContext,
                                         "ErrorContext",
                                         8 * 1024,
                                         8 * 1024,
                                         8 * 1024);
    MemoryContextAllowInCriticalSection(ErrorContext, true);
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, CurrentMemoryContext, ErrorContext, fb(), MemoryContextAllowInCriticalSection(), and TopMemoryContext.

Referenced by main().

MemoryContextIsEmpty()

bool MemoryContextIsEmpty

(

MemoryContext

context

)

Definition at line 792 of file mcxt.c.

{
    Assert(MemoryContextIsValid(context));
 
    /*
     * For now, we consider a memory context nonempty if it has any children;
     * perhaps this should be changed later.
     */
    if (context->firstchild != NULL)
        return false;
    /* Otherwise use the type-specific inquiry */
    return context->methods->is_empty(context);
}

References Assert, fb(), MemoryContextData::firstchild, MemoryContextMethods::is_empty, MemoryContextIsValid, and MemoryContextData::methods.

Referenced by AtSubCommit_Memory().

MemoryContextMemAllocated()

Size MemoryContextMemAllocated	(	MemoryContext	context,
		bool	recurse
	)

Definition at line 811 of file mcxt.c.

{
    Size        total = context->mem_allocated;
 
    Assert(MemoryContextIsValid(context));
 
    if (recurse)
    {
        for (MemoryContext curr = context->firstchild;
             curr != NULL;
             curr = MemoryContextTraverseNext(curr, context))
        {
            total += curr->mem_allocated;
        }
    }
 
    return total;
}

References Assert, fb(), MemoryContextData::firstchild, MemoryContextData::mem_allocated, MemoryContextIsValid, and MemoryContextTraverseNext().

Referenced by hash_agg_check_limits(), hash_agg_update_metrics(), and RT_MEMORY_USAGE().

MemoryContextMemConsumed()

void MemoryContextMemConsumed	(	MemoryContext	context,
		MemoryContextCounters *	consumed
	)

Definition at line 835 of file mcxt.c.

{
    Assert(MemoryContextIsValid(context));
 
    memset(consumed, 0, sizeof(*consumed));
 
    /* Examine the context itself */
    context->methods->stats(context, NULL, NULL, consumed, false);
 
    /* Examine children, using iteration not recursion */
    for (MemoryContext curr = context->firstchild;
         curr != NULL;
         curr = MemoryContextTraverseNext(curr, context))
    {
        curr->methods->stats(curr, NULL, NULL, consumed, false);
    }
}

References Assert, fb(), MemoryContextData::firstchild, MemoryContextIsValid, MemoryContextTraverseNext(), MemoryContextData::methods, and MemoryContextMethods::stats.

Referenced by ExplainExecuteQuery(), and standard_ExplainOneQuery().

MemoryContextRegisterResetCallback()

void MemoryContextRegisterResetCallback	(	MemoryContext	context,
		MemoryContextCallback *	cb
	)

Definition at line 582 of file mcxt.c.

{
    Assert(MemoryContextIsValid(context));
 
    /* Push onto head so this will be called before older registrants. */
    cb->next = context->reset_cbs;
    context->reset_cbs = cb;
    /* Mark the context as non-reset (it probably is already). */
    context->isReset = false;
}

References Assert, MemoryContextData::isReset, MemoryContextIsValid, MemoryContextCallback::next, and MemoryContextData::reset_cbs.

Referenced by expanded_record_fetch_tupdesc(), init_sql_fcache(), InitDomainConstraintRef(), libpqsrv_PGresultSetParent(), libpqsrv_PQwrap(), load_validator_library(), make_expanded_record_from_exprecord(), make_expanded_record_from_tupdesc(), make_expanded_record_from_typeid(), pgoutput_startup(), and PLy_exec_function().

MemoryContextReset()

void MemoryContextReset

(

MemoryContext

context

)

Definition at line 403 of file mcxt.c.

{
    Assert(MemoryContextIsValid(context));
 
    /* save a function call in common case where there are no children */
    if (context->firstchild != NULL)
        MemoryContextDeleteChildren(context);
 
    /* save a function call if no pallocs since startup or last reset */
    if (!context->isReset)
        MemoryContextResetOnly(context);
}

References Assert, fb(), MemoryContextData::firstchild, MemoryContextData::isReset, MemoryContextDeleteChildren(), MemoryContextIsValid, and MemoryContextResetOnly().

Referenced by _brin_parallel_merge(), _bt_preprocess_array_keys(), _gin_parallel_merge(), _SPI_end_call(), AfterTriggerExecute(), apply_spooled_messages(), AtCleanup_Memory(), AtCommit_Memory(), AtEOSubXact_SPI(), AtSubCleanup_Memory(), AutoVacLauncherMain(), BackgroundWriterMain(), bloomBuildCallback(), brin_memtuple_initialize(), bringetbitmap(), brininsert(), bt_check_level_from_leftmost(), btree_redo(), btvacuumpage(), BuildEventTriggerCache(), BuildRelationExtStatistics(), cache_purge_all(), check_domain_for_new_field(), check_domain_for_new_tuple(), CheckpointerMain(), CloneRowTriggersToPartition(), compute_expr_stats(), compute_index_stats(), CopyOneRowTo(), CreateTriggerFiringOn(), do_analyze_rel(), do_autovacuum(), dumptuples(), each_object_field_end(), each_worker_jsonb(), elements_array_element_end(), elements_worker_jsonb(), errfinish(), errstart(), eval_windowaggregates(), EventTriggerInvoke(), exec_dynquery_with_params(), exec_replication_command(), exec_stmt_block(), exec_stmt_dynexecute(), exec_stmt_forc(), exec_stmt_foreach_a(), exec_stmt_open(), exec_stmt_raise(), exec_stmt_return_query(), ExecFindMatchingSubPlans(), ExecHashTableReset(), ExecMakeTableFunctionResult(), ExecProjectSet(), ExecQualAndReset(), ExecRecursiveUnion(), execTuplesUnequal(), execute_foreign_modify(), expanded_record_set_field_internal(), expanded_record_set_tuple(), fetch_more_data(), file_acquire_sample_rows(), FlushErrorState(), get_rel_sync_entry(), get_short_term_cxt(), GetWALRecordsInfo(), GetXLogSummaryStats(), gin_redo(), ginBuildCallback(), ginFlushBuildState(), ginFreeScanKeys(), ginHeapTupleBulkInsert(), ginInsertCleanup(), ginVacuumPostingTreeLeaves(), gist_indexsortbuild(), gist_redo(), gistBuildCallback(), gistgetbitmap(), gistgettuple(), gistinsert(), gistProcessEmptyingQueue(), gistrescan(), gistScanPage(), gistSortedBuildCallback(), heapam_index_build_range_scan(), heapam_index_validate_scan(), IndexCheckExclusion(), init_execution_state(), initialize_windowaggregate(), InvalidateEventCacheCallback(), keyGetItem(), libpqrcv_processTuples(), LogicalParallelApplyLoop(), LogicalRepApplyLoop(), lookup_ts_dictionary_cache(), make_tuple_from_result_row(), perform_work_item(), pg_backup_start(), pg_decode_change(), pg_decode_truncate(), pg_get_wal_block_info(), pgarch_archiveXlog(), pgoutput_change(), pgoutput_truncate(), plperl_return_next_internal(), PLy_input_convert(), PLy_input_from_tuple(), PostgresMain(), printtup(), process_ordered_aggregate_single(), ProcessParallelApplyMessages(), ProcessParallelMessages(), release_partition(), ReScanExprContext(), resetSpGistScanOpaque(), ResetTupleHashTable(), RT_FREE(), scanPendingInsert(), sepgsql_avc_reset(), serializeAnalyzeReceive(), spcache_init(), spg_redo(), spginsert(), spgistBuildCallback(), spgWalk(), startScanKey(), statext_dependencies_build(), storeRow(), stream_stop_internal(), tfuncFetchRows(), tfuncLoadRows(), tuplesort_free(), tuplestore_clear(), validateForeignKeyConstraint(), WalSummarizerMain(), and WalWriterMain().

MemoryContextResetChildren()

void MemoryContextResetChildren

(

MemoryContext

context

)

Definition at line 451 of file mcxt.c.

{
    Assert(MemoryContextIsValid(context));
 
    for (MemoryContext curr = context->firstchild;
         curr != NULL;
         curr = MemoryContextTraverseNext(curr, context))
    {
        MemoryContextResetOnly(curr);
    }
}

References Assert, fb(), MemoryContextData::firstchild, MemoryContextIsValid, MemoryContextResetOnly(), and MemoryContextTraverseNext().

MemoryContextResetOnly()

void MemoryContextResetOnly

(

MemoryContext

context

)

Definition at line 422 of file mcxt.c.

{
    Assert(MemoryContextIsValid(context));
 
    /* Nothing to do if no pallocs since startup or last reset */
    if (!context->isReset)
    {
        MemoryContextCallResetCallbacks(context);
 
        /*
         * If context->ident points into the context's memory, it will become
         * a dangling pointer.  We could prevent that by setting it to NULL
         * here, but that would break valid coding patterns that keep the
         * ident elsewhere, e.g. in a parent context.  So for now we assume
         * the programmer got it right.
         */
 
        context->methods->reset(context);
        context->isReset = true;
    }
}

References Assert, MemoryContextData::isReset, MemoryContextCallResetCallbacks(), MemoryContextIsValid, MemoryContextData::methods, and MemoryContextMethods::reset.

Referenced by AllocSetDelete(), JsonTableResetRowPattern(), MemoryContextReset(), MemoryContextResetChildren(), and mergeruns().

MemoryContextSetIdentifier()

void MemoryContextSetIdentifier	(	MemoryContext	context,
		const char *	id
	)

Definition at line 661 of file mcxt.c.

{
    Assert(MemoryContextIsValid(context));
    context->ident = id;
}

References Assert, MemoryContextData::ident, and MemoryContextIsValid.

Referenced by compile_plperl_function(), compile_pltcl_function(), CopyCachedPlan(), CreateCachedPlan(), CreatePortal(), hash_create(), lookup_ts_dictionary_cache(), plpgsql_compile_callback(), PLy_procedure_create(), RE_compile_and_cache(), sql_compile_callback(), and test_pattern().

MemoryContextSetParent()

void MemoryContextSetParent	(	MemoryContext	context,
		MemoryContext	new_parent
	)

Definition at line 686 of file mcxt.c.

{
    Assert(MemoryContextIsValid(context));
    Assert(context != new_parent);
 
    /* Fast path if it's got correct parent already */
    if (new_parent == context->parent)
        return;
 
    /* Delink from existing parent, if any */
    if (context->parent)
    {
        MemoryContext parent = context->parent;
 
        if (context->prevchild != NULL)
            context->prevchild->nextchild = context->nextchild;
        else
        {
            Assert(parent->firstchild == context);
            parent->firstchild = context->nextchild;
        }
 
        if (context->nextchild != NULL)
            context->nextchild->prevchild = context->prevchild;
    }
 
    /* And relink */
    if (new_parent)
    {
        Assert(MemoryContextIsValid(new_parent));
        context->parent = new_parent;
        context->prevchild = NULL;
        context->nextchild = new_parent->firstchild;
        if (new_parent->firstchild != NULL)
            new_parent->firstchild->prevchild = context;
        new_parent->firstchild = context;
    }
    else
    {
        context->parent = NULL;
        context->prevchild = NULL;
        context->nextchild = NULL;
    }
}

References Assert, fb(), MemoryContextData::firstchild, MemoryContextIsValid, MemoryContextData::nextchild, MemoryContextData::parent, and MemoryContextData::prevchild.

Referenced by _SPI_save_plan(), CachedPlanSetParentContext(), CompleteCachedPlan(), exec_parse_message(), GetCachedExpression(), GetCachedPlan(), load_domaintype_info(), MemoryContextDeleteOnly(), plpgsql_compile_callback(), RE_compile_and_cache(), RelationBuildPartitionDesc(), RelationBuildPartitionKey(), RelationBuildRowSecurity(), RelationRebuildRelation(), RevalidateCachedQuery(), SaveCachedPlan(), SPI_keepplan(), sql_compile_callback(), TransferExpandedObject(), and UploadManifest().

MemoryContextSizeFailure()

void MemoryContextSizeFailure	(	MemoryContext	context,
		Size	size,
		int	flags
	)

Definition at line 1219 of file mcxt.c.

{
    elog(ERROR, "invalid memory alloc request size %zu", size);
}

References elog, and ERROR.

Referenced by MemoryContextCheckSize().

MemoryContextStats()

void MemoryContextStats

(

MemoryContext

context

)

Definition at line 863 of file mcxt.c.

{
    /* Hard-wired limits are usually good enough */
    MemoryContextStatsDetail(context, 100, 100, true);
}

References MemoryContextStatsDetail().

Referenced by AllocSetContextCreateInternal(), BumpContextCreate(), finish_xact_command(), GenerationContextCreate(), MemoryContextAllocationFailure(), SlabContextCreate(), and test_pattern().

MemoryContextStatsDetail()

void MemoryContextStatsDetail	(	MemoryContext	context,
		int	max_level,
		int	max_children,
		bool	print_to_stderr
	)

Definition at line 878 of file mcxt.c.

{
    MemoryContextCounters grand_totals;
 
    memset(&grand_totals, 0, sizeof(grand_totals));
 
    MemoryContextStatsInternal(context, 1, max_level, max_children,
                               &grand_totals, print_to_stderr);
 
    if (print_to_stderr)
        fprintf(stderr,
                "Grand total: %zu bytes in %zu blocks; %zu free (%zu chunks); %zu used\n",
                grand_totals.totalspace, grand_totals.nblocks,
                grand_totals.freespace, grand_totals.freechunks,
                grand_totals.totalspace - grand_totals.freespace);
    else
    {
        /*
         * Use LOG_SERVER_ONLY to prevent the memory contexts from being sent
         * to the connected client.
         *
         * We don't buffer the information about all memory contexts in a
         * backend into StringInfo and log it as one message.  That would
         * require the buffer to be enlarged, risking an OOM as there could be
         * a large number of memory contexts in a backend.  Instead, we log
         * one message per memory context.
         */
        ereport(LOG_SERVER_ONLY,
                (errhidestmt(true),
                 errhidecontext(true),
                 errmsg_internal("Grand total: %zu bytes in %zu blocks; %zu free (%zu chunks); %zu used",
                                 grand_totals.totalspace, grand_totals.nblocks,
                                 grand_totals.freespace, grand_totals.freechunks,
                                 grand_totals.totalspace - grand_totals.freespace)));
    }
}

References ereport, errhidecontext(), errhidestmt(), errmsg_internal(), fb(), fprintf, LOG_SERVER_ONLY, and MemoryContextStatsInternal().

Referenced by MemoryContextStats(), and ProcessLogMemoryContextInterrupt().

MemoryContextStatsInternal()

static void MemoryContextStatsInternal ( MemoryContext  context, int  level, int  max_level, int  max_children, MemoryContextCounters *  totals, bool  print_to_stderr  )

static

Definition at line 925 of file mcxt.c.

{
    MemoryContext child;
    int         ichild;
 
    Assert(MemoryContextIsValid(context));
 
    /* Examine the context itself */
    context->methods->stats(context,
                            MemoryContextStatsPrint,
                            &level,
                            totals, print_to_stderr);
 
    /*
     * Examine children.
     *
     * If we are past the recursion depth limit or already running low on
     * stack, do not print them explicitly but just summarize them. Similarly,
     * if there are more than max_children of them, we do not print the rest
     * explicitly, but just summarize them.
     */
    child = context->firstchild;
    ichild = 0;
    if (level <= max_level && !stack_is_too_deep())
    {
        for (; child != NULL && ichild < max_children;
             child = child->nextchild, ichild++)
        {
            MemoryContextStatsInternal(child, level + 1,
                                       max_level, max_children,
                                       totals,
                                       print_to_stderr);
        }
    }
 
    if (child != NULL)
    {
        /* Summarize the rest of the children, avoiding recursion. */
        MemoryContextCounters local_totals;
 
        memset(&local_totals, 0, sizeof(local_totals));
 
        ichild = 0;
        while (child != NULL)
        {
            child->methods->stats(child, NULL, NULL, &local_totals, false);
            ichild++;
            child = MemoryContextTraverseNext(child, context);
        }
 
        if (print_to_stderr)
        {
            for (int i = 0; i < level; i++)
                fprintf(stderr, "  ");
            fprintf(stderr,
                    "%d more child contexts containing %zu total in %zu blocks; %zu free (%zu chunks); %zu used\n",
                    ichild,
                    local_totals.totalspace,
                    local_totals.nblocks,
                    local_totals.freespace,
                    local_totals.freechunks,
                    local_totals.totalspace - local_totals.freespace);
        }
        else
            ereport(LOG_SERVER_ONLY,
                    (errhidestmt(true),
                     errhidecontext(true),
                     errmsg_internal("level: %d; %d more child contexts containing %zu total in %zu blocks; %zu free (%zu chunks); %zu used",
                                     level,
                                     ichild,
                                     local_totals.totalspace,
                                     local_totals.nblocks,
                                     local_totals.freespace,
                                     local_totals.freechunks,
                                     local_totals.totalspace - local_totals.freespace)));
 
        if (totals)
        {
            totals->nblocks += local_totals.nblocks;
            totals->freechunks += local_totals.freechunks;
            totals->totalspace += local_totals.totalspace;
            totals->freespace += local_totals.freespace;
        }
    }
}

References Assert, ereport, errhidecontext(), errhidestmt(), errmsg_internal(), fb(), MemoryContextData::firstchild, fprintf, i, LOG_SERVER_ONLY, MemoryContextIsValid, MemoryContextStatsInternal(), MemoryContextStatsPrint(), MemoryContextTraverseNext(), MemoryContextData::methods, MemoryContextData::nextchild, stack_is_too_deep(), and MemoryContextMethods::stats.

Referenced by MemoryContextStatsDetail(), and MemoryContextStatsInternal().

MemoryContextStatsPrint()

static void MemoryContextStatsPrint ( MemoryContext  context, void *  passthru, const char *  stats_string, bool  print_to_stderr  )

static

Definition at line 1022 of file mcxt.c.

{
    int         level = *(int *) passthru;
    const char *name = context->name;
    const char *ident = context->ident;
    char        truncated_ident[110];
    int         i;
 
    /*
     * It seems preferable to label dynahash contexts with just the hash table
     * name.  Those are already unique enough, so the "dynahash" part isn't
     * very helpful, and this way is more consistent with pre-v11 practice.
     */
    if (ident && strcmp(name, "dynahash") == 0)
    {
        name = ident;
        ident = NULL;
    }
 
    truncated_ident[0] = '\0';
 
    if (ident)
    {
        /*
         * Some contexts may have very long identifiers (e.g., SQL queries).
         * Arbitrarily truncate at 100 bytes, but be careful not to break
         * multibyte characters.  Also, replace ASCII control characters, such
         * as newlines, with spaces.
         */
        int         idlen = strlen(ident);
        bool        truncated = false;
 
        strcpy(truncated_ident, ": ");
        i = strlen(truncated_ident);
 
        if (idlen > 100)
        {
            idlen = pg_mbcliplen(ident, idlen, 100);
            truncated = true;
        }
 
        while (idlen-- > 0)
        {
            unsigned char c = *ident++;
 
            if (c < ' ')
                c = ' ';
            truncated_ident[i++] = c;
        }
        truncated_ident[i] = '\0';
 
        if (truncated)
            strcat(truncated_ident, "...");
    }
 
    if (print_to_stderr)
    {
        for (i = 1; i < level; i++)
            fprintf(stderr, "  ");
        fprintf(stderr, "%s: %s%s\n", name, stats_string, truncated_ident);
    }
    else
        ereport(LOG_SERVER_ONLY,
                (errhidestmt(true),
                 errhidecontext(true),
                 errmsg_internal("level: %d; %s: %s%s",
                                 level, name, stats_string, truncated_ident)));
}

References ereport, errhidecontext(), errhidestmt(), errmsg_internal(), fb(), fprintf, i, MemoryContextData::ident, ident, LOG_SERVER_ONLY, name, MemoryContextData::name, and pg_mbcliplen().

Referenced by MemoryContextStatsInternal().

MemoryContextStrdup()

char * MemoryContextStrdup	(	MemoryContext	context,
		const char *	string
	)

Definition at line 1768 of file mcxt.c.

{
    char       *nstr;
    Size        len = strlen(string) + 1;
 
    nstr = (char *) MemoryContextAlloc(context, len);
 
    memcpy(nstr, string, len);
 
    return nstr;
}

References fb(), len, and MemoryContextAlloc().

Referenced by _PG_init(), ATExecDetachPartition(), AttrDefaultFetch(), BackendInitialize(), BeginInternalSubTransaction(), cache_single_string(), CheckNNConstraintFetch(), create_pg_locale_builtin(), create_pg_locale_icu(), DefineSavepoint(), exec_dynquery_with_params(), exec_stmt_dynexecute(), exec_stmt_raise(), exec_stmt_return_query(), ExecuteQuery(), IdentifySystem(), init_string_reloption(), InitializeSystemUser(), InitPgFdwOptions(), internalerrquery(), json_object_agg_transfn_worker(), manifest_process_file(), mxid_to_string(), plpython3_inline_handler(), PLy_cursor_plan(), PLy_cursor_query(), PLy_procedure_compile(), PrepareTransactionBlock(), pstrdup(), RelationBuildRowSecurity(), RestoreClientConnectionInfo(), sepgsql_avc_unlabeled(), sepgsql_xact_callback(), set_apply_error_context_origin(), set_authn_id(), set_errdata_field(), SetDatabasePath(), spcache_insert(), SPI_cursor_open_internal(), sql_compile_callback(), and start_table_sync().

MemoryContextTraverseNext()

static MemoryContext MemoryContextTraverseNext ( MemoryContext  curr, MemoryContext  top  )

static

Definition at line 277 of file mcxt.c.

{
    /* After processing a node, traverse to its first child if any */
    if (curr->firstchild != NULL)
        return curr->firstchild;
 
    /*
     * After processing a childless node, traverse to its next sibling if
     * there is one.  If there isn't, traverse back up to the parent (which
     * has already been visited, and now so have all its descendants).  We're
     * done if that is "top", otherwise traverse to its next sibling if any,
     * otherwise repeat moving up.
     */
    while (curr->nextchild == NULL)
    {
        curr = curr->parent;
        if (curr == top)
            return NULL;
    }
    return curr->nextchild;
}

References fb(), MemoryContextData::firstchild, MemoryContextData::nextchild, and MemoryContextData::parent.

Referenced by MemoryContextMemAllocated(), MemoryContextMemConsumed(), MemoryContextResetChildren(), and MemoryContextStatsInternal().

MemoryContextUnregisterResetCallback()

void MemoryContextUnregisterResetCallback	(	MemoryContext	context,
		MemoryContextCallback *	cb
	)

Definition at line 607 of file mcxt.c.

{
    MemoryContextCallback *prev,
               *cur;
 
    Assert(MemoryContextIsValid(context));
 
    for (prev = NULL, cur = context->reset_cbs; cur != NULL;
         prev = cur, cur = cur->next)
    {
        if (cur != cb)
            continue;
        if (prev)
            prev->next = cur->next;
        else
            context->reset_cbs = cur->next;
        return;
    }
    Assert(false);
}

References Assert, cur, fb(), MemoryContextIsValid, MemoryContextCallback::next, cursor::next, and MemoryContextData::reset_cbs.

Referenced by libpqsrv_PGresultSetParent(), and libpqsrv_PQclear().

palloc()

void * palloc

(

Size

size

)

Definition at line 1387 of file mcxt.c.

{
    /* duplicates MemoryContextAlloc to avoid increased overhead */
    void       *ret;
    MemoryContext context = CurrentMemoryContext;
 
    Assert(MemoryContextIsValid(context));
    AssertNotInCriticalSection(context);
 
    context->isReset = false;
 
    /*
     * For efficiency reasons, we purposefully offload the handling of
     * allocation failures to the MemoryContextMethods implementation as this
     * allows these checks to be performed only when an actual malloc needs to
     * be done to request more memory from the OS.  Additionally, not having
     * to execute any instructions after this call allows the compiler to use
     * the sibling call optimization.  If you're considering adding code after
     * this call, consider making it the responsibility of the 'alloc'
     * function instead.
     */
    ret = context->methods->alloc(context, size, 0);
    /* We expect OOM to be handled by the alloc function */
    Assert(ret != NULL);
    VALGRIND_MEMPOOL_ALLOC(context, ret, size);
 
    return ret;
}

References MemoryContextMethods::alloc, Assert, AssertNotInCriticalSection, CurrentMemoryContext, fb(), MemoryContextData::isReset, MemoryContextIsValid, MemoryContextData::methods, and VALGRIND_MEMPOOL_ALLOC.

Referenced by _bt_bottomupdel_pass(), _bt_dedup_pass(), _bt_delitems_delete_check(), _bt_delitems_update(), _bt_load(), _bt_mkscankey(), _bt_newlevel(), _bt_preprocess_array_keys(), _bt_simpledel_pass(), _bt_unmark_keys(), _intbig_alloc(), _ltree_picksplit(), _metaphone(), AbsorbSyncRequests(), accum_sum_copy(), accumArrayResultArr(), aclitemout(), aclmembers(), acquire_inherited_sample_rows(), add_exact_object_address_extra(), add_reloption(), addWrd(), adjust_appendrel_attrs_mutator(), allocate_recordbuf(), allocate_reloption(), AllocateRelationDesc(), AlterSubscription_refresh(), anybit_typmodout(), anychar_typmodout(), appendJSONKeyValueFmt(), AppendStringCommandOption(), apply_spooled_messages(), array_agg_array_combine(), array_agg_array_deserialize(), array_create_iterator(), array_map(), array_out(), array_recv(), array_replace_internal(), array_set_element(), ArrayGetIntegerTypmods(), Async_Notify(), autoinc(), bbsink_copystream_begin_backup(), be_loread(), be_tls_get_certificate_hash(), BeginCopyFrom(), binary_decode(), binary_encode(), binaryheap_allocate(), BipartiteMatch(), bit_and(), bit_catenate(), bit_or(), bit_out(), bit_recv(), bitfromint4(), bitfromint8(), bitnot(), bits_to_text(), bitsetbit(), bitshiftleft(), bitshiftright(), bitsubstring(), bitxor(), bms_copy(), boolout(), bottomup_sort_and_shrink(), box_poly(), bpchar(), bpchar_input(), bqarr_in(), brin_build_desc(), brin_copy_tuple(), brin_minmax_multi_distance_inet(), brin_page_items(), brin_range_deserialize(), brin_revmap_data(), bringetbitmap(), bt_normalize_tuple(), bt_page_items_internal(), bt_page_print_tuples(), btbeginscan(), btree_xlog_dedup(), btree_xlog_updates(), btreevacuumposting(), btrescan(), BufferSync(), build_column_frequencies(), build_distinct_groups(), build_function_result_tupdesc_d(), build_mvndistinct(), build_pertrans_for_aggref(), build_server_final_message(), build_server_first_message(), build_tlist_index(), build_tlist_index_other_vars(), build_tuplestore_recursively(), BuildTupleFromCStrings(), bytea_catenate(), bytea_reverse(), bytea_string_agg_finalfn(), byteain(), byteaout(), bytearecv(), calc_word_similarity(), CatalogCacheCreateEntry(), catenate_stringinfo_string(), char_bpchar(), char_text(), charout(), check_foreign_key(), check_ident_usermap(), check_primary_key(), check_temp_tablespaces(), checkSharedDependencies(), chr(), cidout(), cleanup_tsquery_stopwords(), collect_corrupt_items(), collectTSQueryValues(), compute_array_stats(), compute_distinct_stats(), compute_expr_stats(), compute_index_stats(), compute_range_stats(), compute_scalar_stats(), compute_tsvector_stats(), computeLeafRecompressWALData(), concat_text(), connect_pg_server(), consider_groupingsets_paths(), convert_prep_stmt_params(), convert_requires_to_datum(), convert_string_datum(), copy_file(), copy_pathtarget(), copy_plpgsql_datums(), CopyFromTextLikeStart(), CopyIndexTuple(), CopyLimitPrintoutLength(), copytext(), CopyTriggerDesc(), core_yyalloc(), core_yyrealloc(), count_usable_fds(), create_hash_bounds(), create_limit_plan(), create_list_bounds(), create_memoize_plan(), create_mergejoin_plan(), create_range_bounds(), create_secmsg(), CreateConstraintEntry(), CreateFunction(), CreatePartitionPruneState(), createPostingTree(), CreateTemplateTupleDesc(), CreateTriggerFiringOn(), CreateTupleDescCopyConstr(), cstring_to_text_with_len(), cube_recv(), current_database(), current_schemas(), dataBeginPlaceToPageLeaf(), datetime_format_has_tz(), datetime_to_char_body(), datumCopy(), datumRestore(), datumSerialize(), debackslash(), decodePageSplitRecord(), DeescapeQuotedString(), deparse_lquery(), deparse_ltree(), deserialize_deflist(), detoast_attr(), detoast_attr_slice(), detoast_external_attr(), disassembleLeaf(), DiscreteKnapsack(), div_var(), do_analyze_rel(), do_to_timestamp(), dobyteatrim(), DoCopyTo(), doPickSplit(), dotrim(), double_to_shortest_decimal(), downcase_convert(), downcase_identifier(), DropRelationsAllBuffers(), duplicate_numeric(), encrypt_password(), entry_dealloc(), enum_range_internal(), ExecAggRetrieveInstrumentation(), ExecBitmapHeapRetrieveInstrumentation(), ExecBitmapIndexScanRetrieveInstrumentation(), ExecEvalArrayExpr(), ExecGather(), ExecGatherMerge(), ExecGetJsonValueItemString(), ExecHashJoinGetSavedTuple(), ExecHashRetrieveInstrumentation(), ExecIncrementalSortRetrieveInstrumentation(), ExecIndexBuildScanKeys(), ExecIndexOnlyScanRetrieveInstrumentation(), ExecIndexScanRetrieveInstrumentation(), ExecInitAgg(), ExecInitAppend(), ExecInitExprRec(), ExecInitIndexScan(), ExecInitJunkFilter(), ExecInitMemoize(), ExecInitPartitionDispatchInfo(), ExecInitSubPlan(), ExecInitValuesScan(), ExecMakeTableFunctionResult(), ExecMemoizeRetrieveInstrumentation(), ExecParallelCreateReaders(), ExecParallelRetrieveInstrumentation(), ExecParallelSetupTupleQueues(), ExecSortRetrieveInstrumentation(), execTuplesHashPrepare(), execTuplesMatchPrepare(), ExecuteTruncateGuts(), ExplainCreateWorkersState(), extract_rollup_sets(), fallbackSplit(), file_acquire_sample_rows(), find_hash_columns(), find_in_path(), find_inheritance_children_extended(), FinishWalRecovery(), float4_to_char(), float4out(), float8_to_char(), float8out_internal(), float_to_shortest_decimal(), format_operator_extended(), format_procedure_extended(), formTextDatum(), formTextDatum(), FuncnameGetCandidates(), g_cube_picksplit(), g_int_picksplit(), g_intbig_picksplit(), gbt_bit_xfrm(), gbt_bool_union(), gbt_cash_union(), gbt_date_union(), gbt_enum_union(), gbt_float4_union(), gbt_float8_union(), gbt_inet_union(), gbt_int2_union(), gbt_int4_union(), gbt_int8_union(), gbt_intv_compress(), gbt_intv_union(), gbt_num_picksplit(), gbt_oid_union(), gbt_time_union(), gbt_ts_union(), gbt_uuid_compress(), gbt_uuid_union(), gbt_var_key_from_datum(), gbt_var_picksplit(), gen_random_uuid(), generate_normalized_query(), generate_restrict_key(), generate_trgm(), generate_trgm_only(), generate_uuidv7(), generate_wildcard_trgm(), generateHeadline(), genericPickSplit(), get_attribute_options(), get_environ(), get_extension_aux_control_filename(), get_extension_control_directories(), get_extension_script_filename(), get_func_arg_info(), get_func_input_arg_names(), get_func_signature(), get_func_trftypes(), get_name_for_var_field(), get_page_from_raw(), get_permutation(), get_raw_page_internal(), get_str_from_var(), get_str_from_var_sci(), get_tsearch_config_filename(), get_val(), GetMultiXactIdMembers(), GetPermutation(), GetRunningTransactionLocks(), GetWALBlockInfo(), ghstore_alloc(), ghstore_picksplit(), gin_extract_hstore(), gin_extract_hstore_query(), gin_leafpage_items(), GinBufferStoreTuple(), ginCompressPostingList(), GinDataLeafPageGetItems(), GinFormInteriorTuple(), ginHeapTupleFastInsert(), ginMergeItemPointers(), ginNewScanKey(), ginPostingListDecodeAllSegments(), ginReadTuple(), ginReadTupleWithoutState(), ginRedoRecompress(), ginVacuumPostingTreeLeaf(), gist_box_picksplit(), gist_indexsortbuild(), gist_indexsortbuild_levelstate_flush(), gist_page_items_bytea(), gistbeginscan(), gistfillitupvec(), gistGetItupFromPage(), gistgettuple(), gistMakeUnionItVec(), gistrescan(), gistScanPage(), gistSplitByKey(), gistSplitHalf(), gseg_picksplit(), gtrgm_alloc(), gtrgm_consistent(), gtrgm_picksplit(), gtsquery_picksplit(), gtsvector_alloc(), gtsvector_penalty(), gtsvector_picksplit(), hash_object_field_end(), hashagg_batch_read(), hashbpchar(), hashbpcharextended(), hashtext(), hashtextextended(), heap_copy_minimal_tuple(), heap_copy_tuple_as_datum(), heap_copytuple(), heap_copytuple_with_tuple(), heap_multi_insert(), heap_page_items(), heap_tuple_from_minimal_tuple(), hladdword(), hmac_finish(), hstore_akeys(), hstore_avals(), hstore_concat(), hstore_delete(), hstore_delete_array(), hstore_delete_hstore(), hstore_from_array(), hstore_from_arrays(), hstore_from_record(), hstore_out(), hstore_populate_record(), hstore_recv(), hstore_slice_to_array(), hstore_slice_to_hstore(), hstore_subscript_assign(), hstore_to_array_internal(), hstoreArrayToPairs(), hstorePairs(), icu_language_tag(), ImportSnapshot(), inet_gist_picksplit(), inet_set_masklen(), init_sexpr(), init_slab_allocator(), init_tsvector_parser(), InitDeadLockChecking(), InitJumble(), InitPostmasterChildSlots(), initStringInfoInternal(), InitWalRecovery(), inplaceGetInvalidationMessages(), int2out(), int2vectorout(), int44in(), int44out(), int4_to_char(), int4out(), int8_to_char(), int8out(), int_to_roman(), interpret_AS_clause(), interpret_function_parameter_list(), intervaltypmodout(), irbt_alloc(), json_manifest_finalize_file(), jsonb_object_keys(), JsonbValueToJsonb(), JsonEncodeDateTime(), jsonpath_yyalloc(), jsonpath_yyrealloc(), leafRepackItems(), libpqrcv_readtimelinehistoryfile(), like_fixed_prefix(), like_fixed_prefix_ci(), litbufdup(), llvm_compile_expr(), lo_get_fragment_internal(), load_domaintype_info(), load_enum_cache_data(), load_relcache_init_file(), logfile_getname(), logical_heap_rewrite_flush_mappings(), logicalrep_read_tuple(), LogicalRepSyncTableStart(), LogicalTapeFreeze(), LogicalTapeSetCreate(), LogicalTapeWrite(), lookup_var_attr_stats(), lpad(), lrq_alloc(), ltree2text(), ltree_gist_alloc(), ltree_picksplit(), ltree_prefix_eq_ci(), ltsInitReadBuffer(), lz4_compress_datum(), lz4_decompress_datum(), lz4_decompress_datum_slice(), macaddr8_out(), macaddr_out(), make_build_data(), make_colname_unique(), make_greater_string(), make_jsp_entry_node(), make_jsp_expr_node(), make_partitionedrel_pruneinfo(), make_pathtarget_from_tlist(), make_result_safe(), make_sort_from_groupcols(), make_sort_from_sortclauses(), make_text_key(), make_tuple_from_result_row(), make_tuple_indirect(), makeitem(), makeObjectName(), makeParamList(), mark_hl_fragments(), MatchNamedCall(), MatchText(), mbuf_create(), minimal_tuple_from_heap_tuple(), mock_scram_secret(), moveLeafs(), mul_var(), mXactCacheGetById(), new_list(), newLexeme(), nodeRead(), NUM_cache(), numeric_sortsupport(), numeric_to_char(), numeric_to_number(), numerictypmodout(), oid8out(), oidout(), oidvectorout(), oidvectortypes(), OpernameGetCandidates(), optionListToArray(), order_qual_clauses(), ordered_set_startup(), pad_eme_pkcs1_v15(), PageGetTempPage(), PageGetTempPageCopy(), PageGetTempPageCopySpecial(), palloc_btree_page(), parse_compress_specification(), parse_fcall_arguments(), parse_one_reloption(), parse_scram_secret(), parse_tsquery(), ParseLongOption(), parseRelOptions(), partition_bounds_copy(), path_add(), path_in(), path_poly(), path_recv(), percentile_cont_multi_final_common(), percentile_disc_multi_final(), PerformRadiusTransaction(), pg_armor(), pg_blocking_pids(), pg_convert(), pg_current_snapshot(), pg_dearmor(), pg_decrypt(), pg_decrypt_iv(), pg_detoast_datum_copy(), pg_digest(), pg_encrypt(), pg_encrypt_iv(), pg_get_constraintdef_worker(), pg_get_logical_snapshot_info(), pg_get_userbyid(), pg_hmac(), pg_import_system_collations(), pg_listening_channels(), pg_random_bytes(), pg_safe_snapshot_blocking_pids(), pg_snapshot_recv(), pglz_compress_datum(), pglz_decompress_datum(), pglz_decompress_datum_slice(), pgp_extract_armor_headers(), pgp_key_id_w(), pgp_mpi_alloc(), pgrowlocks(), pgss_shmem_startup(), pgstat_fetch_entry(), pgstat_get_transactional_drops(), placeChar(), plaintree(), plperl_spi_exec_prepared(), plperl_spi_prepare(), plperl_spi_query_prepared(), plperl_to_hstore(), plpgsql_ns_additem(), plpython_to_hstore(), pltcl_quote(), pltcl_SPI_execute_plan(), pltcl_SPI_prepare(), PLy_cursor_plan(), PLy_procedure_munge_source(), PLy_spi_execute_plan(), PLyObject_ToBytea(), pnstrdup(), policy_role_list_to_array(), poly_path(), populate_record(), populate_recordset_object_field_end(), populate_scalar(), PostmasterMain(), pq_getmsgtext(), prepare_sort_from_pathkeys(), prepare_sql_fn_parse_info(), preparePresortedCols(), preprocess_grouping_sets(), PrescanPreparedTransactions(), ProcessStartupPacket(), prs_setup_firstcall(), psprintf(), pullf_create(), pushf_create(), px_find_hmac(), QTNCopy(), queryin(), queue_listen(), quote_identifier(), quote_literal(), quote_literal_cstr(), range_gist_picksplit(), RE_compile(), RE_compile_and_cache(), read_binary_file(), read_client_final_message(), read_stream_begin_impl(), read_whole_file(), readDatum(), readtup_heap(), ReadTwoPhaseFile(), rebuild_database_list(), record_cmp(), record_eq(), record_image_cmp(), record_image_eq(), record_in(), record_recv(), regclassout(), regcollationout(), regcomp_auth_token(), regconfigout(), regdatabaseout(), regdictionaryout(), regexec_auth_token(), regexp_fixed_prefix(), regnamespaceout(), regoperout(), regprocout(), regroleout(), regtypeout(), RelationBuildPartitionDesc(), RelationBuildTriggers(), RememberToFreeTupleDescAtEOX(), remove_dbtablespaces(), ReorderBufferQueueMessage(), repeat(), replace_text_regexp(), report_json_context(), resizeString(), rot13_passphrase(), rpad(), save_state_data(), scanner_init(), scram_build_secret(), scram_verify_plain_password(), SearchCatCacheList(), secure_open_server(), seg_out(), select_outer_pathkeys_for_merge(), sepgsql_fmgr_hook(), seq_redo(), serialize_expr_stats(), SerializeTransactionState(), set_relation_column_names(), set_rtable_names(), set_var_from_str(), setup_firstcall(), setup_pct_info(), setup_regexp_matches(), setup_test_matches(), show_trgm(), similar_escape_internal(), slot_fill_defaults(), spg_text_inner_consistent(), spg_text_leaf_consistent(), spgAllocSearchItem(), spgist_name_inner_consistent(), spgNewHeapItem(), SplitToVariants(), StartPrepare(), startScanKey(), statext_mcv_build(), statext_mcv_deserialize(), statext_ndistinct_build(), statext_ndistinct_deserialize(), statext_ndistinct_serialize(), StoreRelCheck(), str_casefold(), str_initcap(), str_tolower(), str_toupper(), str_udeescape(), string_to_bytea_const(), strlower_libc_mb(), strncoll_libc(), strnxfrm_libc(), strtitle_libc_mb(), strupper_libc_mb(), subxact_info_add(), subxact_info_read(), sync_queue_init(), test_custom_stats_var_from_serialized_data(), test_enc_conversion(), test_pattern(), test_random(), test_re_compile(), test_resowner_many(), test_resowner_priorities(), testdelete(), text_catenate(), text_reverse(), text_substring(), text_to_bits(), text_to_cstring(), TidListEval(), toast_fetch_datum(), toast_fetch_datum_slice(), toast_save_datum(), transformRelOptions(), translate(), TS_phrase_output(), ts_process_call(), tsqueryout(), tsqueryrecv(), tsquerytree(), tsvector_setweight(), tsvector_setweight_by_filter(), tsvector_to_array(), tsvector_unnest(), tsvectorout(), tuple_data_split_internal(), tuplesort_begin_batch(), tuplesort_putbrintuple(), tuplesort_putgintuple(), tuplestore_begin_common(), unicode_is_normalized(), unicode_normalize_func(), update_attstats(), uuid_decrement(), uuid_increment(), uuid_out(), uuid_recv(), uuid_skipsupport(), vac_open_indexes(), varbit(), varbit_out(), varbit_recv(), varstr_levenshtein(), varstr_sortsupport(), xid8out(), xidout(), XLogInsertRecord(), XLogReadRecordAlloc(), xml_recv(), xpath_string(), xpath_table(), yyalloc(), and yyrealloc().

palloc0()

void * palloc0

(

Size

size

)

Definition at line 1417 of file mcxt.c.

{
    /* duplicates MemoryContextAllocZero to avoid increased overhead */
    void       *ret;
    MemoryContext context = CurrentMemoryContext;
 
    Assert(MemoryContextIsValid(context));
    AssertNotInCriticalSection(context);
 
    context->isReset = false;
 
    ret = context->methods->alloc(context, size, 0);
    /* We expect OOM to be handled by the alloc function */
    Assert(ret != NULL);
    VALGRIND_MEMPOOL_ALLOC(context, ret, size);
 
    MemSetAligned(ret, 0, size);
 
    return ret;
}

References MemoryContextMethods::alloc, Assert, AssertNotInCriticalSection, CurrentMemoryContext, fb(), MemoryContextData::isReset, MemoryContextIsValid, MemSetAligned, MemoryContextData::methods, and VALGRIND_MEMPOOL_ALLOC.

Referenced by _bt_form_posting(), _bt_truncate(), _bt_unmark_keys(), _bt_update_posting(), _gin_build_tuple(), _ltq_extract_regex(), _ltree_extract_isparent(), _ltree_extract_risparent(), _ltxtq_extract_exec(), accum_sum_rescale(), add_column_to_pathtarget(), add_sp_item_to_pathtarget(), allocacl(), allocateReloptStruct(), AllocateSnapshotBuilder(), AlterObjectNamespace_internal(), AlterObjectOwner_internal(), AlterObjectRename_internal(), appendSCRAMKeysInfo(), array_cat(), array_get_slice(), array_in(), array_map(), array_recv(), array_replace_internal(), array_set_element(), array_set_slice(), array_to_tsvector(), BeginCopyFrom(), BeginCopyTo(), bernoulli_initsamplescan(), BipartiteMatch(), bit(), bit_in(), BlockRefTableEntryMarkBlockModified(), bloom_create(), bloom_init(), BloomFormTuple(), bms_add_range(), bms_make_singleton(), bpchar_name(), brin_bloom_opcinfo(), brin_form_placeholder_tuple(), brin_form_tuple(), brin_inclusion_opcinfo(), brin_minmax_multi_opcinfo(), brin_minmax_multi_union(), brin_minmax_opcinfo(), brin_new_memtuple(), brin_range_serialize(), bt_page_print_tuples(), build_expanded_ranges(), build_expr_data(), build_mvdependencies(), build_sorted_items(), buildint2vector(), buildNSItemFromLists(), buildNSItemFromTupleDesc(), buildoidvector(), calc_word_similarity(), circle_poly(), collect_visibility_data(), combo_init(), compact_palloc0(), compile_plperl_function(), compile_pltcl_function(), connect_pg_server(), construct_md_array(), copy_ltree(), create_array_envelope(), create_groupingsets_plan(), crosstab(), cryptohash_internal(), cube_a_f8(), cube_a_f8_f8(), cube_c_f8(), cube_c_f8_f8(), cube_enlarge(), cube_f8(), cube_f8_f8(), cube_inter(), cube_subset(), cube_union_v0(), cvt_text_name(), deparse_context_for_plan_tree(), dependencies_object_end(), do_analyze_rel(), dsm_impl_mmap(), EnumValuesCreate(), eqjoinsel(), ExecBuildGroupingEqual(), ExecBuildHash32Expr(), ExecBuildHash32FromAttrs(), ExecBuildParamSetEqual(), ExecEvalArrayExpr(), ExecEvalHashedScalarArrayOp(), ExecGrant_Relation(), ExecIndexBuildScanKeys(), ExecInitAppend(), ExecInitBitmapAnd(), ExecInitBitmapOr(), ExecInitExprRec(), ExecInitFunc(), ExecInitGenerated(), ExecInitIndexScan(), ExecInitJsonExpr(), ExecInitJunkFilterConversion(), ExecInitRangeTable(), ExecInitResultRelation(), ExecInitSetOp(), ExecInitSubscriptingRef(), ExecInitValuesScan(), expand_partitioned_rtentry(), expand_tuple(), expand_virtual_generated_columns(), ExplainCreateWorkersState(), extract_rollup_sets(), extract_variadic_args(), fetch_more_data(), fetch_remote_table_info(), fillFakeState(), find_window_functions(), findeq(), formrdesc(), g_intbig_consistent(), gather_merge_setup(), gbt_macad8_union(), gbt_macad_union(), gbt_num_bin_union(), gbt_num_compress(), gbt_var_key_copy(), gbt_var_node_truncate(), generate_base_implied_equalities_no_const(), get_crosstab_tuplestore(), get_matching_partitions(), get_relation_info(), GetAccessStrategyWithSize(), getColorInfo(), ginExtractEntries(), ginNewScanKey(), gist_indexsortbuild_levelstate_add(), grow_notnull_info(), heap_form_minimal_tuple(), heap_form_tuple(), heap_toast_insert_or_update(), heap_vacuum_rel(), hmac_init(), identify_join_columns(), init_returning_filter(), InitCatCache(), initHyperLogLog(), initSpGistState(), inittapes(), inline_function(), inner_subltree(), InstrAlloc(), int2vectorin(), interpret_function_parameter_list(), jsonb_exec_setup(), lca_inner(), leader_takeover_tapes(), leftmostvalue_name(), logicalrep_read_tuple(), ltree_concat(), ltree_picksplit(), ltree_union(), make_auth_token(), make_inh_translation_list(), make_multirange(), make_partitionedrel_pruneinfo(), make_setop_translation_list(), make_sort_input_target(), make_tsvector(), make_tuple_from_result_row(), make_tuple_indirect(), makeArrayResultArr(), MakeTupleTableSlot(), mergeruns(), minmax_multi_init(), MJExamineQuals(), mkVoidAffix(), multi_sort_init(), multirange_constructor2(), multirange_get_range(), multirange_intersect_internal(), multirange_minus_internal(), multirange_union(), nameconcatoid(), namein(), namerecv(), ndistinct_object_end(), new_intArrayType(), newNode(), newRegisNode(), oidvectorin(), ParallelSlotsSetup(), parse_lquery(), parse_ltree(), parse_tsquery(), pg_crypt(), pgoutput_truncate(), pgp_init(), plperl_modify_tuple(), plsample_func_handler(), pltcl_build_tuple_result(), PLy_modify_tuple(), poly_in(), poly_recv(), prepare_query_params(), PrepareForIncrementalBackup(), preparePresortedCols(), printtup_prepare_info(), pull_up_constant_function(), pull_up_simple_subquery(), pull_up_simple_values(), px_crypt_shacrypt(), QTN2QT(), queryin(), range_agg_finalfn(), range_serialize(), RelationBuildLocalRelation(), ReorderBufferProcessTXN(), ReorderBufferToastReplace(), reverse_name(), rewriteTargetListIU(), rewriteValuesRTE(), serialize_prepare_info(), set_append_rel_size(), set_deparse_for_query(), set_join_column_names(), set_plan_references(), set_simple_column_names(), set_subquery_pathlist(), SetExplainExtensionState(), SnapBuildSerialize(), spgFormInnerTuple(), spgFormLeafTuple(), spgFormNodeTuple(), spgist_name_leaf_consistent(), standard_join_search(), statext_dependencies_build(), statext_dependencies_deserialize(), statext_dependencies_serialize(), statext_mcv_build(), statext_mcv_deserialize(), statext_mcv_serialize(), statext_ndistinct_deserialize(), test_create(), testdelete(), text_name(), toast_flatten_tuple_to_datum(), transformFromClauseItem(), transformSetOperationStmt(), transformValuesClause(), transformWithClause(), tsqueryrecv(), tsvector_concat(), tsvector_delete_arr(), tsvector_delete_by_indices(), tsvector_filter(), tsvector_strip(), tsvectorin(), tsvectorrecv(), TupleDescGetAttInMetadata(), tuplesort_begin_cluster(), tuplesort_begin_heap(), tuplesort_begin_index_btree(), tuplesort_begin_index_gin(), tuplesort_begin_index_gist(), vacuum_all_databases(), and varbit_in().

palloc_aligned()

void * palloc_aligned	(	Size	size,
		Size	alignto,
		int	flags
	)

Definition at line 1606 of file mcxt.c.

{
    return MemoryContextAllocAligned(CurrentMemoryContext, size, alignto, flags);
}

References CurrentMemoryContext, fb(), and MemoryContextAllocAligned().

Referenced by _mdfd_getseg(), GenericXLogStart(), InitCatCache(), and modify_rel_block().

palloc_extended()

void * palloc_extended	(	Size	size,
		int	flags
	)

Definition at line 1439 of file mcxt.c.

{
    /* duplicates MemoryContextAllocExtended to avoid increased overhead */
    void       *ret;
    MemoryContext context = CurrentMemoryContext;
 
    Assert(MemoryContextIsValid(context));
    AssertNotInCriticalSection(context);
 
    context->isReset = false;
 
    ret = context->methods->alloc(context, size, flags);
    if (unlikely(ret == NULL))
    {
        /* NULL can be returned only when using MCXT_ALLOC_NO_OOM */
        Assert(flags & MCXT_ALLOC_NO_OOM);
        return NULL;
    }
 
    VALGRIND_MEMPOOL_ALLOC(context, ret, size);
 
    if ((flags & MCXT_ALLOC_ZERO) != 0)
        MemSetAligned(ret, 0, size);
 
    return ret;
}

References MemoryContextMethods::alloc, Assert, AssertNotInCriticalSection, CurrentMemoryContext, fb(), MemoryContextData::isReset, MCXT_ALLOC_NO_OOM, MCXT_ALLOC_ZERO, MemoryContextIsValid, MemSetAligned, MemoryContextData::methods, unlikely, and VALGRIND_MEMPOOL_ALLOC.

Referenced by AllocDeadEndChild(), apw_dump_now(), pg_clean_ascii(), and XLogReaderAllocate().

pchomp()

char * pchomp

(

const char *

in

)

Definition at line 1809 of file mcxt.c.

{
    size_t      n;
 
    n = strlen(in);
    while (n > 0 && in[n - 1] == '\n')
        n--;
    return pnstrdup(in, n);
}

References fb(), and pnstrdup().

Referenced by connect_pg_server(), dblink_connect(), dblink_error_message(), dblink_get_conn(), dblink_res_error(), dblink_res_internalerror(), dblink_send_query(), GetConnection(), libpqrcv_alter_slot(), libpqrcv_connect(), libpqrcv_create_slot(), libpqrcv_endstreaming(), libpqrcv_exec(), libpqrcv_identify_system(), libpqrcv_readtimelinehistoryfile(), libpqrcv_receive(), libpqrcv_send(), libpqrcv_startstreaming(), libpqsrv_cancel(), pgfdw_cancel_query_end(), pgfdw_report_internal(), and storeQueryResult().

pfree()

void pfree

(

void *

pointer

)

Definition at line 1616 of file mcxt.c.

{
#ifdef USE_VALGRIND
    MemoryContext context = GetMemoryChunkContext(pointer);
#endif
 
    MCXT_METHOD(pointer, free_p) (pointer);
 
    VALGRIND_MEMPOOL_FREE(context, pointer);
}

References GetMemoryChunkContext(), MCXT_METHOD, and VALGRIND_MEMPOOL_FREE.

Referenced by _brin_parallel_merge(), _bt_array_decrement(), _bt_array_increment(), _bt_array_set_low_or_high(), _bt_bottomupdel_pass(), _bt_buildadd(), _bt_dedup_finish_pending(), _bt_dedup_pass(), _bt_delitems_delete(), _bt_delitems_delete_check(), _bt_delitems_vacuum(), _bt_doinsert(), _bt_findsplitloc(), _bt_freestack(), _bt_getroot(), _bt_gettrueroot(), _bt_insert_parent(), _bt_insertonpg(), _bt_load(), _bt_newlevel(), _bt_parallel_restore_arrays(), _bt_pendingfsm_finalize(), _bt_preprocess_array_keys(), _bt_simpledel_pass(), _bt_skiparray_set_element(), _bt_skiparray_set_isnull(), _bt_sort_dedup_finish_pending(), _bt_split(), _bt_spooldestroy(), _bt_truncate(), _bt_unmark_keys(), _bt_uppershutdown(), _fdvec_resize(), _gin_build_tuple(), _gin_process_worker_data(), _h_spooldestroy(), _hash_splitbucket(), _hash_squeezebucket(), _int_contains(), _int_inter(), _int_overlap(), _int_same(), _int_union(), _lca(), _mdfd_getseg(), AbsorbSyncRequests(), accum_sum_rescale(), accumArrayResultArr(), aclmerge(), add_partial_path(), add_path(), addArcs(), AddEnumLabel(), AddFileToBackupManifest(), addFkRecurseReferenced(), addHLParsedLex(), addItemPointersToLeafTuple(), addKey(), adjust_appendrel_attrs_multilevel(), adjust_child_relids_multilevel(), advance_windowaggregate(), advance_windowaggregate_base(), afterTriggerDeleteHeadEventChunk(), AfterTriggerEndSubXact(), afterTriggerFreeEventList(), afterTriggerRestoreEventList(), agg_refill_hash_table(), AlignedAllocFree(), AlignedAllocRealloc(), allocate_recordbuf(), AlterObjectNamespace_internal(), AlterObjectOwner_internal(), AlterObjectRename_internal(), appendJSONKeyValueFmt(), appendSCRAMKeysInfo(), AppendStringCommandOption(), appendStringInfoStringQuoted(), apply_scanjoin_target_to_paths(), apw_dump_now(), array_free_iterator(), array_in(), array_map(), array_out(), array_recv(), array_replace_internal(), array_reverse_n(), array_send(), array_set_element_expanded(), array_shuffle_n(), array_to_json_internal(), array_to_jsonb_internal(), array_to_text_internal(), arrayconst_cleanup_fn(), arrayexpr_cleanup_fn(), ArrayGetIntegerTypmods(), ASN1_STRING_to_text(), assign_simple_var(), AssignTransactionId(), astreamer_extractor_free(), astreamer_plain_writer_free(), astreamer_recovery_injector_free(), astreamer_tar_archiver_free(), astreamer_tar_parser_free(), astreamer_tar_terminator_free(), astreamer_verify_free(), Async_Notify(), AtEOSubXact_Inval(), AtEOSubXact_on_commit_actions(), AtEOSubXact_PgStat(), AtEOSubXact_PgStat_DroppedStats(), AtEOSubXact_PgStat_Relations(), AtEOXact_GUC(), AtEOXact_on_commit_actions(), AtEOXact_PgStat_DroppedStats(), AtEOXact_RelationCache(), ATPrepAlterColumnType(), AtSubAbort_childXids(), AtSubAbort_Notify(), AtSubAbort_Snapshot(), AtSubCommit_childXids(), AtSubCommit_Notify(), AttrDefaultFetch(), autoinc(), BackendInitialize(), bbsink_server_begin_archive(), bbsink_server_begin_manifest(), bbsink_server_end_manifest(), be_tls_close(), be_tls_open_server(), binaryheap_free(), bind_param_error_callback(), BipartiteMatchFree(), blendscan(), blgetbitmap(), BlockRefTableEntryMarkBlockModified(), BlockRefTableFreeEntry(), BlockRefTableReaderNextRelation(), bloom_free(), blrescan(), bms_add_members(), bms_del_member(), bms_del_members(), bms_free(), bms_int_members(), bms_intersect(), bms_join(), bms_replace_members(), boolop(), BootstrapModeMain(), bottomup_sort_and_shrink(), bpcharfastcmp_c(), bpcharrecv(), bqarr_in(), brin_bloom_union(), brin_build_desc(), brin_form_tuple(), brin_free_tuple(), brin_inclusion_add_value(), brin_inclusion_union(), brin_minmax_add_value(), brin_minmax_multi_distance_inet(), brin_minmax_multi_union(), brin_minmax_union(), brin_page_items(), brinendscan(), brininsertcleanup(), brinRevmapTerminate(), brinsummarize(), bt_check_level_from_leftmost(), bt_child_check(), bt_child_highkey_check(), bt_downlink_missing_check(), bt_leftmost_ignoring_half_dead(), bt_normalize_tuple(), bt_page_print_tuples(), bt_right_page_check_scankey(), bt_rootdescend(), bt_target_page_check(), bt_tuple_present_callback(), btendscan(), btinsert(), btree_xlog_updates(), btvacuumpage(), buf_finalize(), BufferSync(), BufFileClose(), BufFileOpenFileSet(), build_child_join_sjinfo(), build_EvalXFuncInt(), build_index_paths(), build_local_reloptions(), build_mvdependencies(), build_mvndistinct(), build_pertrans_for_aggref(), build_reloptions(), build_sorted_items(), buildFreshLeafTuple(), BuildRestoreCommand(), BuildTupleFromCStrings(), bytea_abbrev_convert(), byteafastcmp(), cache_single_string(), cached_function_compile(), calc_arraycontsel(), calc_distr(), calc_rank_and(), calc_rank_cd(), calc_rank_or(), calc_word_similarity(), calculate_partition_bound_for_merge(), cancel_on_dsm_detach(), casefold(), cash_words(), CatalogCloseIndexes(), CatCacheFreeKeys(), CatCacheRemoveCList(), CatCacheRemoveCTup(), char2wchar(), check_application_name(), check_circularity(), check_cluster_name(), check_control_files(), check_createrole_self_grant(), check_datestyle(), check_db_file_conflict(), check_debug_io_direct(), check_default_text_search_config(), check_ident_usermap(), check_locale(), check_log_connections(), check_log_destination(), check_oauth_validator(), check_partitions_for_split(), check_publications(), check_publications_origin_sequences(), check_publications_origin_tables(), check_relation_privileges(), check_restrict_nonsystem_relation_kind(), check_schema_perms(), check_search_path(), check_synchronized_standby_slots(), check_temp_tablespaces(), check_timezone(), check_wal_consistency_checking(), CheckAffix(), CheckAlterSubOption(), checkclass_str(), checkcondition_str(), CheckForBufferLeaks(), CheckForLocalBufferLeaks(), CheckIndexCompatible(), CheckMD5Auth(), CheckNNConstraintFetch(), CheckPasswordAuth(), CheckPointTwoPhase(), CheckPWChallengeAuth(), CheckRADIUSAuth(), CheckSASLAuth(), checkSharedDependencies(), choose_plan_name(), ChooseConstraintName(), ChooseExtendedStatisticName(), ChooseRelationName(), citext_eq(), citext_hash(), citext_hash_extended(), citext_ne(), citextcmp(), clauselist_apply_dependencies(), clauselist_selectivity_ext(), clean_NOT_intree(), clean_stopword_intree(), cleanup_directories_atexit(), cleanup_subxact_info(), clear_and_pfree(), close_tsvector_parser(), ClosePostmasterPorts(), collectMatchBitmap(), combo_free(), combo_init(), CompactCheckpointerRequestQueue(), compareJsonbContainers(), compareStrings(), compile_plperl_function(), compile_pltcl_function(), compileTheLexeme(), compileTheSubstitute(), compute_array_stats(), compute_tsvector_stats(), concat_internal(), connect_pg_server(), construct_empty_expanded_array(), convert_any_priv_string(), convert_charset(), convert_column_name(), convert_string_datum(), convert_to_scalar(), convertPgWchar(), copy_connection(), copy_dest_destroy(), copy_file(), copy_table(), CopyArrayEls(), CopyFromErrorCallback(), CopyFromTextLikeOneRow(), CopyMultiInsertBufferCleanup(), copyTemplateDependencies(), core_yyfree(), count_usable_fds(), create_cursor(), create_hash_bounds(), create_list_bounds(), create_partitionwise_grouping_paths(), create_range_bounds(), create_script_for_old_cluster_deletion(), create_secmsg(), create_tablespace_directories(), CreateCheckPoint(), CreateDatabaseUsingFileCopy(), CreateDatabaseUsingWalLog(), createdb(), createPostingTree(), CreateStatistics(), CreateTableSpace(), CreateTriggerFiringOn(), croak_cstr(), crosstab(), cstr2sv(), datetime_format_has_tz(), datetime_to_char_body(), datum_image_eq(), datum_image_hash(), datum_to_json_internal(), datumSerialize(), db_encoding_convert(), dbase_redo(), DCH_to_char(), deallocate_query(), DecodeTextArrayToBitmapset(), DeconstructFkConstraintRow(), DefineDomain(), DefineEnum(), DefineRange(), DefineType(), deleteSplitPartitionContext(), deparseConst(), dependencies_clauselist_selectivity(), DependencyGenerator_free(), deserialize_deflist(), destroy_tablespace_directories(), DestroyBlockRefTableReader(), DestroyBlockRefTableWriter(), DestroyParallelContext(), destroyStringInfo(), DestroyTupleQueueReader(), detoast_attr(), detoast_attr_slice(), digest_free(), dintdict_lexize(), dir_realloc(), dispell_init(), dispell_lexize(), div_var(), do_analyze_rel(), do_autovacuum(), Do_MultiXactIdWait(), do_pg_backup_start(), do_pg_backup_stop(), do_text_output_multiline(), do_to_timestamp(), DoesMultiXactIdConflict(), dofindsubquery(), dotrim(), DropRelationFiles(), DropRelationsAllBuffers(), dsa_detach(), dshash_destroy(), dshash_detach(), dsimple_lexize(), dsm_create(), dsm_detach(), dsm_impl_sysv(), dsnowball_lexize(), dsynonym_init(), dsynonym_lexize(), dxsyn_lexize(), ecpg_filter_source(), ecpg_filter_stderr(), ecpg_postprocess_result(), elog_node_display(), emit_audit_message(), encrypt_free(), end_tup_output(), EndCopy(), EndCopyFrom(), enlarge_list(), entry_dealloc(), entry_purge_tuples(), entryLoadMoreItems(), enum_range_internal(), enum_recv(), EnumValuesCreate(), eqjoinsel(), escape_json_text(), eval_windowaggregates(), EventTriggerAlterTableEnd(), EventTriggerSQLDropAddObject(), examine_attribute(), examine_attribute(), examine_expression(), exec_bind_message(), exec_command_conninfo(), exec_command_unrestrict(), exec_object_restorecon(), exec_stmt_foreach_a(), ExecAggCopyTransValue(), ExecDropSingleTupleTableSlot(), ExecEndWindowAgg(), ExecEvalPreOrderedDistinctSingle(), ExecEvalXmlExpr(), ExecFetchSlotHeapTupleDatum(), ExecForceStoreHeapTuple(), ExecForceStoreMinimalTuple(), ExecGrant_Attribute(), ExecGrant_common(), ExecGrant_Largeobject(), ExecGrant_Parameter(), ExecGrant_Relation(), ExecHashIncreaseNumBatches(), ExecHashRemoveNextSkewBucket(), ExecHashTableDestroy(), ExecIndexBuildScanKeys(), ExecInitGenerated(), ExecInitHashJoin(), ExecInitMemoize(), ExecParallelCleanup(), ExecParallelFinish(), ExecParallelHashCloseBatchAccessors(), ExecParallelHashRepartitionRest(), ExecReScanTidScan(), ExecResetTupleTable(), ExecSetParamPlan(), ExecSetSlotDescriptor(), ExecShutdownGatherMergeWorkers(), ExecShutdownGatherWorkers(), execute_foreign_modify(), executeDateTimeMethod(), executeItemOptUnwrapTarget(), ExecuteRecoveryCommand(), expand_dynamic_library_name(), expanded_record_set_field_internal(), expanded_record_set_fields(), expanded_record_set_tuple(), ExplainFlushWorkersState(), ExplainProperty(), ExplainPropertyFloat(), ExplainPropertyList(), ExplainQuery(), extract_autovac_opts(), extract_rollup_sets(), fetch_finfo_record(), fetch_function_defaults(), fetch_relation_list(), fetch_remote_slots(), fetch_remote_table_info(), fetch_statentries_for_relation(), file_acquire_sample_rows(), filter_list_to_array(), finalize_aggregates(), FinalizeIncrementalManifest(), find_in_path(), find_in_paths(), find_inheritance_children_extended(), find_other_exec(), find_provider(), findDependentObjects(), findeq(), findJsonbValueFromContainer(), finish_edata(), FinishPreparedTransaction(), fix_merged_indexes(), fixup_inherited_columns(), flush_pipe_input(), FlushRelationsAllBuffers(), fmgr_info_C_lang(), fmgr_info_cxt_security(), ForgetBackgroundWorker(), ForgetManyTestResources(), form_and_insert_tuple(), form_and_spill_tuple(), free_attrmap(), free_attstatsslot(), free_child_join_sjinfo(), free_chromo(), free_conversion_map(), free_edge_table(), free_object_addresses(), free_openssl_cipher(), free_openssl_digest(), free_parsestate(), free_partition_map(), free_pool(), free_sort_tuple(), FreeAccessStrategy(), freeAndGetParent(), FreeBulkInsertState(), FreeConfigVariable(), FreeErrorData(), FreeErrorDataContents(), FreeExprContext(), FreeFakeRelcacheEntry(), freeGinBtreeStack(), freeHyperLogLog(), FreeOldMultiXactReader(), FreeQueryDesc(), FreeSnapshot(), FreeSubscription(), freetree(), FreeTriggerDesc(), FreeTupleDesc(), FreeWaitEventSet(), FreeWaitEventSetAfterFork(), FreezeMultiXactId(), func_get_detail(), FuncnameGetCandidates(), g_int_compress(), g_int_consistent(), g_int_decompress(), g_int_penalty(), g_int_picksplit(), g_intbig_consistent(), g_intbig_picksplit(), gather_merge_clear_tuples(), gbt_bit_l2n(), gen_ossl_free(), generate_append_tlist(), generate_base_implied_equalities_no_const(), generate_combinations(), generate_dependencies(), generate_error_response(), generate_matching_part_pairs(), generate_trgm_only(), generate_wildcard_trgm(), generateClonedExtStatsStmt(), generateHeadline(), generator_free(), GenericXLogAbort(), GenericXLogFinish(), get_attstatsslot(), get_const_expr(), get_control_dbstate(), get_docrep(), get_extension_aux_control_filename(), get_extension_control_directories(), get_extension_script_filename(), get_flush_position(), get_from_clause(), get_relation_statistics(), get_reloptions(), get_sql_insert(), get_sql_update(), get_str_from_var_sci(), get_target_list(), get_tuple_of_interest(), get_typdefault(), GetAggInitVal(), GetAggInitVal(), GetAggInitVal(), getColorInfo(), GetConfFilesInDir(), getFileContentType(), GetMultiXactIdHintBits(), getNextNearest(), getObjectDescription(), getObjectIdentityParts(), getPublicationSchemaInfo(), GetTempNamespaceProcNumber(), GetWALRecordsInfo(), GetWalStats(), gin_check_parent_keys_consistency(), gin_check_posting_tree_parent_keys_consistency(), gin_extract_jsonb_path(), gin_leafpage_items(), gin_trgm_triconsistent(), GinBufferFree(), GinBufferReset(), GinBufferStoreTuple(), ginCompressPostingList(), ginendscan(), ginEntryFillRoot(), ginEntryInsert(), ginExtractEntries(), ginFinishSplit(), ginFlushBuildState(), GinFormTuple(), ginFreeScanKeys(), ginNewScanKey(), ginPostingListDecodeAllSegmentsToTbm(), ginVacuumEntryPage(), ginVacuumPostingTree(), ginVacuumPostingTreeLeaf(), gist_indexsortbuild(), gist_indexsortbuild_levelstate_flush(), gist_ischild(), gistgetbitmap(), gistgettuple(), gistPopItupFromNodeBuffer(), gistRelocateBuildBuffersOnSplit(), gistrescan(), gistunionsubkeyvec(), gistUnloadNodeBuffer(), group_similar_or_args(), gtrgm_consistent(), gtrgm_distance(), gtrgm_penalty(), gtsvector_penalty(), guc_free(), GUCArrayReset(), hash_record(), hash_record_extended(), hashagg_finish_initial_spills(), hashagg_reset_spill_state(), hashagg_spill_finish(), hashagg_spill_tuple(), hashbpchar(), hashbpcharextended(), hashbuildCallback(), hashendscan(), hashinsert(), hashtext(), hashtextextended(), heap_create_with_catalog(), heap_endscan(), heap_force_common(), heap_free_minimal_tuple(), heap_freetuple(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_modify_tuple(), heap_modify_tuple_by_cols(), heap_tuple_infomask_flags(), heap_tuple_should_freeze(), heap_vacuum_rel(), heapam_index_fetch_end(), heapam_relation_copy_for_cluster(), heapam_tuple_complete_speculative(), heapam_tuple_insert(), heapam_tuple_insert_speculative(), heapam_tuple_update(), hmac_finish(), hmac_free(), hmac_init(), hstoreUniquePairs(), hv_fetch_string(), hv_store_string(), icu_language_tag(), index_compute_xid_horizon_for_tuples(), index_concurrently_create_copy(), index_form_tuple_context(), index_truncate_tuple(), IndexScanEnd(), infix(), infix(), infix(), initcap(), InitExecPartitionPruneContexts(), initialize_reloptions(), InitializeSystemUser(), InitPostgres(), initTrie(), InitWalRecovery(), inner_int_inter(), insert_username(), InsertOneTuple(), InsertPgAttributeTuples(), internal_citext_pattern_cmp(), internalerrquery(), intorel_destroy(), intset_subtract(), inv_close(), inv_getsize(), inv_read(), inv_truncate(), inv_write(), InvalidateAttoptCacheCallback(), InvalidateTableSpaceCacheCallback(), irbt_free(), isAnyTempNamespace(), isolation_start_test(), iterate_jsonb_values(), iterate_word_similarity(), jit_release_context(), json_manifest_finalize_file(), json_manifest_finalize_wal_range(), json_manifest_object_field_start(), json_manifest_scalar(), json_object(), json_object_keys(), json_object_two_arg(), json_parse_manifest_incremental_shutdown(), json_unique_object_end(), json_unique_object_field_start(), jsonb_object(), jsonb_object_two_arg(), jsonb_send(), jsonb_set_element(), JsonbDeepContains(), JsonbValue_to_SV(), JsonItemFromDatum(), jsonpath_send(), jsonpath_yyfree(), KnownAssignedXidsDisplay(), lazy_cleanup_one_index(), lazy_vacuum_one_index(), lca(), leafRepackItems(), libpq_destroy(), libpqrcv_alter_slot(), libpqrcv_connect(), libpqrcv_create_slot(), libpqrcv_disconnect(), libpqrcv_get_option_from_conninfo(), libpqrcv_startstreaming(), libpqsrv_PGresultSetParent(), libpqsrv_PQclear(), like_fixed_prefix(), like_fixed_prefix_ci(), list_delete_first_n(), list_delete_nth_cell(), list_free_private(), llvm_compile_module(), llvm_copy_attributes_at_index(), llvm_release_context(), llvm_resolve_symbol(), llvm_resolve_symbols(), lo_manage(), load_backup_manifest(), load_enum_cache_data(), load_external_function(), load_file(), load_libraries(), load_relcache_init_file(), local_destroy(), LockAcquireExtended(), log_status_format(), logfile_rotate_dest(), logical_heap_rewrite_flush_mappings(), logicalrep_relmap_free_entry(), logicalrep_write_tuple(), LogicalRepSyncSequences(), LogicalTapeClose(), LogicalTapeFreeze(), LogicalTapeRewindForRead(), LogicalTapeSetClose(), LogRecoveryConflict(), LogStandbySnapshot(), lookup_ts_config_cache(), lookup_var_attr_stats(), LookupGXact(), lower(), lquery_recv(), lquery_send(), lrq_free(), ltree_addtext(), ltree_picksplit(), ltree_prefix_eq_ci(), ltree_recv(), ltree_send(), ltree_textadd(), ltxtq_recv(), ltxtq_send(), lz4_compress_datum(), main(), main(), make_greater_string(), make_partition_pruneinfo(), make_partitionedrel_pruneinfo(), make_SAOP_expr(), make_scalar_key(), make_tsvector(), make_tuple_indirect(), makeArrayTypeName(), makeMultirangeConstructors(), map_sql_value_to_xml_value(), mark_hl_fragments(), MatchText(), MaybeRemoveOldWalSummaries(), mbuf_free(), mcelem_array_contained_selec(), mcelem_array_selec(), mcelem_tsquery_selec(), mcv_clause_selectivity_or(), mcv_get_match_bitmap(), mdcbuf_free(), merge_acl_with_grant(), merge_clump(), mergeruns(), mkANode(), moddatetime(), mode_final(), moveArrayTypeName(), movedb(), movedb_failure_callback(), mq_putmessage(), mul_var(), multirange_recv(), MultiXactIdExpand(), MultiXactIdGetUpdateXid(), MultiXactIdIsRunning(), mXactCachePut(), mxid_to_string(), namerecv(), next_field_expand(), NIImportAffixes(), NIImportDictionary(), NIImportOOAffixes(), NINormalizeWord(), NormalizeSubWord(), NUM_cache(), numeric_abbrev_convert(), numeric_fast_cmp(), numeric_float4(), numeric_float8(), numeric_poly_stddev_internal(), numeric_to_number(), numericvar_to_double_no_overflow(), object_aclmask_ext(), overexplain_alias(), overexplain_bitmapset(), overexplain_intlist(), pa_free_worker_info(), pa_launch_parallel_worker(), pad_eme_pkcs1_v15(), PageRestoreTempPage(), pagetable_free(), pair_encode(), pairingheap_free(), parallel_vacuum_end(), parallel_vacuum_init(), parallel_vacuum_process_one_index(), ParameterAclLookup(), parse_and_validate_value(), parse_args(), parse_compress_specification(), parse_extension_control_file(), parse_fcall_arguments(), parse_hba_line(), parse_lquery(), parse_ltree(), parse_manifest_file(), parse_one_reloption(), parse_subscription_options(), parse_tsquery(), parseCommandLine(), ParseConfigFile(), ParseConfigFp(), parseNameAndArgTypes(), parseRelOptionsInternal(), parsetext(), patternsel_common(), pclose_check(), perform_base_backup(), perform_work_item(), PerformAuthentication(), PerformRadiusTransaction(), PerformWalRecovery(), pg_armor(), pg_attribute_aclcheck_all_ext(), pg_attribute_aclmask_ext(), pg_backup_stop(), pg_be_scram_build_secret(), pg_class_aclmask_ext(), pg_convert(), pg_crypt(), pg_dearmor(), pg_decode_commit_txn(), pg_decode_stream_abort(), pg_decode_stream_commit(), pg_encrypt(), pg_extension_update_paths(), pg_get_constraintdef_worker(), pg_get_expr_worker(), pg_get_function_arg_default(), pg_get_indexdef_worker(), pg_get_line(), pg_get_multixact_members(), pg_get_partkeydef_worker(), pg_get_statisticsobj_worker(), pg_get_statisticsobjdef_expressions(), pg_get_wal_block_info(), pg_get_wal_record_info(), pg_identify_object_as_address(), pg_largeobject_aclmask_snapshot(), pg_namespace_aclmask_ext(), pg_parameter_acl_aclmask(), pg_parameter_aclmask(), pg_parse_query(), pg_plan_query(), pg_replication_origin_create(), pg_replication_origin_drop(), pg_replication_origin_oid(), pg_replication_origin_session_setup(), pg_rewrite_query(), pg_split_opts(), pg_stat_file(), pg_stat_get_activity(), pg_stat_get_backend_activity(), pg_stat_statements_internal(), pg_sync_replication_slots(), pg_tablespace_databases(), pg_type_aclmask_ext(), pg_tzenumerate_end(), pg_tzenumerate_next(), pgfnames_cleanup(), pglz_compress_datum(), pgoutput_commit_txn(), pgp_cfb_free(), pgp_create_pkt_reader(), pgp_free(), pgp_key_free(), pgp_mpi_free(), pgss_shmem_startup(), pgss_store(), pgstat_delete_pending_entry(), pgstat_release_entry_ref(), pkt_stream_free(), pktreader_free(), plainnode(), plperl_build_tuple_result(), plperl_call_perl_func(), plperl_hash_from_tuple(), plperl_modify_tuple(), plperl_spi_exec_prepared(), plperl_spi_prepare(), plperl_spi_query_prepared(), plperl_sv_to_datum(), plperl_trigger_handler(), plperl_util_elog(), plpgsql_compile_callback(), plpgsql_destroy_econtext(), plpgsql_extra_checks_check_hook(), plpgsql_subxact_cb(), pltcl_build_tuple_argument(), pltcl_func_handler(), pltcl_quote(), pltcl_set_tuple_values(), pltcl_trigger_handler(), PLy_abort_open_subtransactions(), PLy_elog_impl(), PLy_function_drop_args(), PLy_function_restore_args(), PLy_input_setup_tuple(), PLy_modify_tuple(), PLy_output(), PLy_output_setup_tuple(), PLy_pop_execution_context(), PLy_procedure_compile(), PLy_procedure_create(), PLy_quote_literal(), PLy_quote_nullable(), PLy_subtransaction_exit(), PLy_traceback(), PLy_trigger_build_args(), PLyGenericObject_ToComposite(), PLyMapping_ToComposite(), PLyNumber_ToJsonbValue(), PLySequence_ToComposite(), PLyUnicode_Bytes(), PLyUnicode_FromScalar(), PLyUnicode_FromStringAndSize(), PopActiveSnapshot(), PopTransaction(), populate_array(), populate_record(), populate_scalar(), PortalDrop(), postgresExecForeignTruncate(), postgresGetForeignJoinPaths(), PostmasterMain(), PostPrepare_smgr(), pprint(), pq_cleanup_redirect_to_shm_mq(), pq_endmessage(), pq_puttextmessage(), pq_sendcountedtext(), pq_sendstring(), pq_sendtext(), pq_writestring(), PrepareTempTablespaces(), preprocessNamespacePath(), PrescanPreparedTransactions(), print(), print_expr(), print_function_arguments(), printtup_destroy(), printtup_prepare_info(), printtup_shutdown(), ProcArrayApplyRecoveryInfo(), process_directory_recursively(), process_ordered_aggregate_single(), process_pipe_input(), process_postgres_switches(), process_rel_infos(), process_target_wal_block_change(), ProcessCommittedInvalidationMessages(), ProcessConfigFileInternal(), ProcessGUCArray(), ProcessParallelApplyMessages(), ProcessParallelMessages(), ProcessPgArchInterrupts(), ProcessStandbyHSFeedbackMessage(), ProcessStandbyReplyMessage(), ProcessStartupPacket(), ProcessWalSndrMessage(), ProcSleep(), prs_process_call(), prune_element_hashtable(), prune_lexemes_hashtable(), psprintf(), psql_add_command(), psql_start_test(), pullf_free(), pushf_free(), PushTransaction(), pushval_morph(), px_crypt_shacrypt(), px_find_cipher(), px_find_combo(), px_find_digest(), QTNFree(), QTNTernary(), queryin(), range_fast_cmp(), range_recv(), rbt_populate(), RE_compile(), RE_compile_and_cache(), RE_execute(), read_client_final_message(), read_dictionary(), read_stream_end(), ReadArrayStr(), readfile(), readstoplist(), recheck_relation_needs_vacanalyze(), reconstruct_from_incremental_file(), record_cmp(), record_eq(), record_image_cmp(), record_image_eq(), record_in(), record_out(), record_recv(), record_send(), recordMultipleDependencies(), RecordTransactionAbort(), RecordTransactionCommit(), RecoverPreparedTransactions(), recursive_revoke(), recv_password_packet(), regcomp_auth_token(), regex_fixed_prefix(), regexec_auth_token(), regexp_fixed_prefix(), regression_main(), RehashCatCache(), RehashCatCacheLists(), reindex_one_database(), ReinitializeParallelDSM(), RelationBuildPartitionKey(), RelationBuildPublicationDesc(), RelationBuildRowSecurity(), RelationBuildRuleLock(), RelationBuildTriggers(), RelationBuildTupleDesc(), RelationCacheInitializePhase3(), RelationDestroyRelation(), RelationGetDummyIndexExpressions(), RelationGetIndexAttOptions(), RelationGetIndexExpressions(), RelationGetIndexPredicate(), RelationInvalidateRelation(), RelationParseRelOptions(), RelationPreserveStorage(), RelationReloadIndexInfo(), ReleaseDummy(), ReleaseManyTestResource(), ReleasePostmasterChildSlot(), relmap_redo(), remove_cache_entry(), remove_dbtablespaces(), remove_leftjoinrel_from_query(), remove_self_join_rel(), RemoveLocalLock(), RenameTypeInternal(), ReorderBufferAddDistributedInvalidations(), ReorderBufferFreeChange(), ReorderBufferFreeRelids(), ReorderBufferFreeSnap(), ReorderBufferFreeTupleBuf(), ReorderBufferFreeTXN(), ReorderBufferIterTXNFinish(), ReorderBufferToastReplace(), ReorderBufferToastReset(), reorderqueue_pop(), replace_auto_config_value(), replace_text(), replace_text_regexp(), replication_scanner_finish(), ReplicationSlotDropAtPubNode(), ReplicationSlotRelease(), ReplicationSlotValidateName(), ReplSlotSyncWorkerMain(), report_corruption_internal(), report_triggers(), reportDependentObjects(), ReportGUCOption(), ReportSlotInvalidation(), reset_directory_cleanup_list(), reset_on_dsm_detach(), ResetDecoder(), resetSpGistScanOpaque(), resolve_aggregate_transtype(), ResourceOwnerDelete(), ResourceOwnerEnlarge(), ResourceOwnerReleaseAll(), RestoreArchivedFile(), RestoreArchivedFile(), rewriteTargetListIU(), rewriteValuesRTE(), rm_redo_error_callback(), rmtree(), RS_free(), RT_END_ITERATE(), RT_FREE(), RT_FREE_LEAF(), RT_FREE_NODE(), run_ssl_passphrase_command(), scanner_finish(), scanPendingInsert(), scram_verify_plain_password(), secure_open_server(), select_active_windows(), select_outer_pathkeys_for_merge(), send_message_to_frontend(), send_message_to_server_log(), sendDir(), SendFunctionResult(), sepgsql_attribute_drop(), sepgsql_attribute_post_create(), sepgsql_attribute_relabel(), sepgsql_attribute_setattr(), sepgsql_avc_check_perms(), sepgsql_avc_compute(), sepgsql_avc_reclaim(), sepgsql_database_drop(), sepgsql_database_post_create(), sepgsql_database_relabel(), sepgsql_database_setattr(), sepgsql_proc_drop(), sepgsql_proc_execute(), sepgsql_proc_post_create(), sepgsql_proc_relabel(), sepgsql_proc_setattr(), sepgsql_relation_drop(), sepgsql_relation_post_create(), sepgsql_relation_relabel(), sepgsql_relation_setattr(), sepgsql_relation_truncate(), sepgsql_schema_drop(), sepgsql_schema_post_create(), sepgsql_schema_relabel(), sepgsql_xact_callback(), seq_redo(), seq_search_localized(), serialize_deflist(), serialize_prepare_info(), serializeAnalyzeDestroy(), serializeAnalyzeShutdown(), set_append_rel_size(), set_customscan_references(), set_foreignscan_references(), set_indexonlyscan_references(), set_join_references(), set_plan_refs(), set_returning_clause_references(), set_subquery_pathlist(), set_upper_references(), set_var_from_str(), set_windowagg_runcondition_references(), SetClientEncoding(), setCorrLex(), setNewTmpRes(), setup_regexp_matches(), setup_test_matches(), shdepLockAndCheckObject(), shell_archive_file(), shell_finish_command(), shm_mq_detach(), shm_mq_receive(), show_memoize_info(), show_trgm(), show_window_def(), show_window_keys(), ShowAllGUCConfig(), ShowTransactionStateRec(), ShowUsage(), ShutdownExprContext(), ShutdownWalRecovery(), similarity(), single_encode(), slotsync_reread_config(), smgr_bulk_flush(), smgrDoPendingDeletes(), smgrDoPendingSyncs(), smgrdounlinkall(), SnapBuildFreeSnapshot(), SnapBuildPurgeOlderTxn(), SnapBuildRestore(), SnapBuildSerialize(), spg_box_quad_inner_consistent(), spgClearPendingList(), spgdoinsert(), spgendscan(), spgFreeSearchItem(), spggettuple(), spgRedoVacuumRedirect(), SPI_cursor_open(), SPI_modifytuple(), SPI_pfree(), split_text(), SplitIdentifierString(), SplitToVariants(), sqlfunction_destroy(), StandbyRecoverPreparedTransactions(), StandbyTransactionIdIsPrepared(), start_table_sync(), StartPrepare(), startScanEntry(), StartupRereadConfig(), StartupXLOG(), statatt_build_stavalues(), statext_dependencies_free(), statext_mcv_build(), statext_mcv_deserialize(), statext_mcv_free(), statext_mcv_serialize(), statext_ndistinct_free(), StoreAttrDefault(), storeObjectDescription(), StorePartitionKey(), StoreRelCheck(), storeRow(), string_to_text(), stringToQualifiedNameList(), strlower_libc_mb(), strncoll_libc(), strnxfrm_libc(), strtitle_libc_mb(), strupper_libc_mb(), sts_end_write(), sts_read_tuple(), SummarizeWAL(), sync_queue_destroy(), SyncPostCheckpoint(), syncrep_scanner_finish(), SyncRepGetNthLatestSyncRecPtr(), SyncRepGetSyncRecPtr(), SysLogger_Start(), SysLoggerMain(), systable_beginscan(), systable_beginscan_ordered(), systable_endscan(), systable_endscan_ordered(), table_recheck_autovac(), tablesample_init(), TablespaceCreateDbspace(), tbm_end_private_iterate(), tbm_end_shared_iterate(), tbm_free(), terminate_brin_buildstate(), test_basic(), test_bms_overlap_list(), test_custom_stats_var_from_serialized_data(), test_destroy(), test_enc_conversion(), test_protocol_version(), test_random(), test_random_operations(), test_re_compile(), test_shm_mq_setup(), test_singlerowmode(), testdelete(), testprs_end(), text2ltree(), text_format(), text_format_string_conversion(), text_substring(), text_to_cstring(), text_to_cstring_buffer(), textrecv(), textToQualifiedNameList(), thesaurus_lexize(), thesaurusRead(), TidListEval(), TidStoreDestroy(), TidStoreDetach(), TidStoreEndIterate(), toast_build_flattened_tuple(), toast_close_indexes(), toast_compress_datum(), toast_flatten_tuple(), toast_flatten_tuple_to_datum(), toast_tuple_cleanup(), toast_tuple_externalize(), toast_tuple_try_compression(), tokenize_auth_file(), tokenize_expand_file(), tokenize_include_file(), TParserClose(), TParserCopyClose(), TParserGet(), tqueueDestroyReceiver(), tqueueReceiveSlot(), TransformGUCArray(), transformRangeTableFunc(), transientrel_destroy(), try_partitionwise_join(), ts_accum(), TS_execute_locations_recurse(), ts_headline_byid_opt(), ts_headline_json_byid_opt(), ts_headline_jsonb_byid_opt(), ts_lexize(), ts_match_tq(), ts_match_tt(), ts_process_call(), ts_stat_sql(), tsearch_readline(), tsearch_readline_end(), tsquery_rewrite_query(), tsqueryrecv(), tsquerytree(), tstoreDestroyReceiver(), tstoreReceiveSlot_detoast(), tstoreShutdownReceiver(), tsvector_delete_arr(), tsvector_to_array(), tsvector_update_trigger(), tsvectorin(), tt_process_call(), tts_virtual_clear(), tuple_data_split(), tuple_data_split_internal(), tuplesort_begin_batch(), tuplesort_begin_cluster(), tuplesort_begin_index_btree(), tuplestore_advance(), tuplestore_end(), tuplestore_skiptuples(), tuplestore_trim(), typeDepNeeded(), typenameTypeMod(), unaccent_dict(), uniqueentry(), uniqueWORD(), unistr(), UnregisterExprContextCallback(), UnregisterResourceReleaseCallback(), UnregisterSubXactCallback(), UnregisterXactCallback(), updateAclDependenciesWorker(), UpdateIndexRelation(), UpdateLogicalMappings(), upper(), uuid_decrement(), uuid_increment(), vac_close_indexes(), validate(), validate_remote_info(), varcharrecv(), varlenafastcmp_locale(), varstr_abbrev_convert(), varstrfastcmp_c(), verify_backup_checksums(), verify_cb(), verify_control_file(), verify_plain_backup_directory(), verify_tar_backup(), wait_for_connection_state(), WaitForOlderSnapshots(), WaitForParallelWorkersToExit(), walrcv_clear_result(), WalRcvFetchTimeLineHistoryFiles(), WalReceiverMain(), worker_freeze_result_tape(), write_auto_conf_file(), write_console(), write_csvlog(), write_jsonlog(), write_reconstructed_file(), X509_NAME_field_to_text(), X509_NAME_to_cstring(), XLogDecodeNextRecord(), XLogDumpDisplayRecord(), XLogInsertRecord(), XLogPrefetcherFree(), XLogReaderAllocate(), XLogReaderFree(), XLogReleasePreviousRecord(), XLOGShmemInit(), xml_encode_special_chars(), xml_out_internal(), xml_recv(), xml_send(), xmlconcat(), xmlpi(), xpath_bool(), xpath_list(), xpath_nodeset(), xpath_number(), xpath_string(), xpath_table(), and yyfree().

pnstrdup()

char * pnstrdup	(	const char *	in,
		Size	len
	)

Definition at line 1792 of file mcxt.c.

{
    char       *out;
 
    len = strnlen(in, len);
 
    out = palloc(len + 1);
    memcpy(out, in, len);
    out[len] = '\0';
 
    return out;
}

References fb(), len, and palloc().

Referenced by appendStringInfoStringQuoted(), asc_initcap(), asc_tolower(), asc_toupper(), BaseBackup(), char2wchar(), DCH_from_char(), dintdict_lexize(), dsynonym_lexize(), dxsyn_lexize(), exec_bind_message(), executeItemOptUnwrapTarget(), find_extension_control_filename(), get_prompt(), get_source_line(), getJsonPathVariable(), hstore_to_plperl(), HV_to_JsonbValue(), JsonbUnquote(), JsonbValue_to_SV(), llvm_split_symbol_name(), makeMultirangeTypeName(), multirange_in(), parse_extension_control_file(), parse_format(), parse_jsonb_index_flags(), pchomp(), pgstat_clip_activity(), populate_scalar(), read_dictionary(), script_error_callback(), split_path(), splitTableColumnsSpec(), and SplitToVariants().

ProcessLogMemoryContextInterrupt()

void ProcessLogMemoryContextInterrupt

(

void

)

Definition at line 1340 of file mcxt.c.

{
    LogMemoryContextPending = false;
 
    /*
     * Exit immediately if memory context logging is already in progress. This
     * prevents recursive calls, which could occur if logging is requested
     * repeatedly and rapidly, potentially leading to infinite recursion and a
     * crash.
     */
    if (LogMemoryContextInProgress)
        return;
    LogMemoryContextInProgress = true;
 
    PG_TRY();
    {
        /*
         * Use LOG_SERVER_ONLY to prevent this message from being sent to the
         * connected client.
         */
        ereport(LOG_SERVER_ONLY,
                (errhidestmt(true),
                 errhidecontext(true),
                 errmsg("logging memory contexts of PID %d", MyProcPid)));
 
        /*
         * When a backend process is consuming huge memory, logging all its
         * memory contexts might overrun available disk space. To prevent
         * this, we limit the depth of the hierarchy, as well as the number of
         * child contexts to log per parent to 100.
         *
         * As with MemoryContextStats(), we suppose that practical cases where
         * the dump gets long will typically be huge numbers of siblings under
         * the same parent context; while the additional debugging value from
         * seeing details about individual siblings beyond 100 will not be
         * large.
         */
        MemoryContextStatsDetail(TopMemoryContext, 100, 100, false);
    }
    PG_FINALLY();
    {
        LogMemoryContextInProgress = false;
    }
    PG_END_TRY();
}

References ereport, errhidecontext(), errhidestmt(), errmsg(), LOG_SERVER_ONLY, LogMemoryContextInProgress, LogMemoryContextPending, MemoryContextStatsDetail(), MyProcPid, PG_END_TRY, PG_FINALLY, PG_TRY, and TopMemoryContext.

Referenced by ProcessAutoVacLauncherInterrupts(), ProcessCheckpointerInterrupts(), ProcessInterrupts(), ProcessMainLoopInterrupts(), ProcessPgArchInterrupts(), ProcessStartupProcInterrupts(), and ProcessWalSummarizerInterrupts().

pstrdup()

char * pstrdup

(

const char *

in

)

Definition at line 1781 of file mcxt.c.

{
    return MemoryContextStrdup(CurrentMemoryContext, in);
}

References CurrentMemoryContext, and MemoryContextStrdup().

Referenced by AbsoluteConfigLocation(), accesstype_arg_to_string(), add_row_identity_var(), add_with_check_options(), addCompiledLexeme(), addFkConstraint(), addRangeTableEntryForFunction(), addRangeTableEntryForGroup(), addRangeTableEntryForSubquery(), addRangeTableEntryForTableFunc(), addRangeTableEntryForValues(), AddRelationNotNullConstraints(), addToResult(), allocate_reloption(), AllocSlruSegState(), AlterRole(), analyzeCTETargetList(), anytime_typmodout(), anytimestamp_typmodout(), append_database_pattern(), append_relation_pattern_helper(), append_schema_pattern(), ApplyRetrieveRule(), array_out(), astreamer_extractor_new(), astreamer_gzip_writer_new(), astreamer_plain_writer_new(), ATExecAddIndexConstraint(), ATExecAlterConstraint(), ATExecAlterConstrEnforceability(), ATParseTransformCmd(), BaseBackupAddTarget(), BeginCopyFrom(), BeginCopyTo(), BootstrapModeMain(), BufFileCreateFileSet(), BufFileOpenFileSet(), build_datatype(), build_minmax_path(), build_server_first_message(), buildDefItem(), BuildOnConflictExcludedTargetlist(), buildRelationAliases(), BuildRestoreCommand(), CatalogCacheInitializeCache(), check_createrole_self_grant(), check_datestyle(), check_debug_io_direct(), check_hostname(), check_locale(), check_log_connections(), check_log_destination(), check_oauth_validator(), check_restrict_nonsystem_relation_kind(), check_search_path(), check_selective_binary_conversion(), check_synchronized_standby_slots(), check_temp_tablespaces(), check_timezone(), check_tuple_header(), check_tuple_visibility(), check_valid_internal_signature(), check_wal_consistency_checking(), checkInsertTargets(), choose_plan_name(), ChooseExtendedStatisticNameAddition(), ChooseForeignKeyConstraintNameAddition(), ChooseIndexColumnNames(), ChooseIndexNameAddition(), CloneRowTriggersToPartition(), compile_database_list(), compile_plperl_function(), compile_pltcl_function(), compile_relation_list_one_db(), compileTheSubstitute(), connectby_text(), connectby_text_serial(), convert_GUC_name_for_parameter_acl(), convert_string_datum(), CopyCachedPlan(), CopyErrorData(), CopyLimitPrintoutLength(), CopyTriggerDesc(), copyTSLexeme(), CopyVar(), create_foreign_modify(), CreateCachedPlan(), CreateLockFile(), createNewConnection(), CreateParallelContext(), CreateSchemaCommand(), createTableConstraints(), CreateTableSpace(), CreateTupleDescCopyConstr(), cstring_in(), cstring_out(), datasegpath(), date_out(), dbase_redo(), defGetString(), DefineQueryRewrite(), DefineView(), DefineViewRules(), deleteConnection(), destroy_tablespace_directories(), DetachPartitionFinalize(), determineNotNullFlags(), determineRecursiveColTypes(), do_pg_backup_start(), DoCopy(), DropSubscription(), dsynonym_init(), ean13_out(), encrypt_password(), enum_out(), exec_bind_message(), exec_command_restrict(), exec_execute_message(), executeItemOptUnwrapTarget(), expand_dynamic_library_name(), expand_inherited_rtentry(), expand_insert_targetlist(), expand_single_inheritance_child(), ExpandRowReference(), expandRTE(), expandTableLikeClause(), expandTupleDesc(), ExportSnapshot(), extension_file_exists(), extract_slot_names(), ExtractExtensionList(), fetch_statentries_for_relation(), fill_hba_line(), filter_list_to_array(), find_in_paths(), find_plan(), flatten_set_variable_args(), float4in_internal(), float8in_internal(), fmgr_symbol(), format_operator_parts(), format_procedure_parts(), format_type_extended(), from_char_seq_search(), generate_append_tlist(), generate_setop_tlist(), generateClonedIndexStmt(), generateJsonTablePathName(), get_am_name(), get_attname(), get_collation(), get_collation_actual_version_libc(), get_collation_name(), get_configdata(), get_connect_string(), get_constraint_name(), get_database_list(), get_database_name(), get_ext_ver_info(), get_ext_ver_list(), get_extension_control_directories(), get_extension_name(), get_extension_script_directory(), get_file_fdw_attribute_options(), get_func_name(), get_language_name(), get_namespace_name(), get_namespace_name_or_temp(), get_opclass(), get_opfamily_name(), get_opname(), get_publication_name(), get_rel_name(), get_rolespec_name(), get_source_line(), get_sql_insert(), get_sql_update(), get_subscription_list(), get_subscription_name(), get_tablespace_location(), get_tablespace_name(), getAdditionalACLs(), getAttributesList(), GetConfFilesInDir(), GetConfigOptionValues(), getConnectionByName(), GetDatabasePath(), GetForeignDataWrapperExtended(), GetForeignServerExtended(), GetJsonBehaviorValueString(), getNamespaces(), getObjectIdentityParts(), getOpFamilyIdentity(), GetPublication(), getRecoveryStopReason(), getRelationIdentity(), getRelationStatistics(), GetSubscription(), getTokenTypes(), GetUserNameFromId(), GetWaitEventCustomNames(), gtsvectorout(), heap_vacuum_rel(), hstore_out(), ImportForeignSchema(), indent_lines(), injection_points_attach(), InjectionPointList(), internal_yylex(), interpret_AS_clause(), interpret_function_parameter_list(), interval_out(), isn_out(), iterate_values_object_field_start(), json_build_object_worker(), JsonbUnquote(), JsonTableInitOpaque(), lazy_cleanup_one_index(), lazy_vacuum_one_index(), libpqrcv_check_conninfo(), libpqrcv_create_slot(), libpqrcv_get_conninfo(), libpqrcv_get_option_from_conninfo(), libpqrcv_get_senderinfo(), libpqrcv_identify_system(), libpqrcv_readtimelinehistoryfile(), llvm_error_message(), llvm_function_reference(), llvm_set_target(), llvm_split_symbol_name(), load_domaintype_info(), load_libraries(), Lock_AF_UNIX(), logicalrep_partition_open(), logicalrep_read_attrs(), logicalrep_read_origin(), logicalrep_read_rel(), logicalrep_read_typ(), logicalrep_relmap_update(), LogicalRepSyncSequences(), main(), main(), make_rfile(), makeAlias(), makeColumnDef(), makeJsonTablePathSpec(), makeMultirangeTypeName(), map_sql_value_to_xml_value(), MarkGUCPrefixReserved(), MergeAttributes(), MergeCheckConstraint(), name_active_windows(), nameout(), network_out(), new_ExtensionControlFile(), NINormalizeWord(), NormalizeSubWord(), nullable_string(), numeric_normalize(), numeric_out(), numeric_out_sci(), oauth_exchange(), obtain_object_name_namespace(), okeys_object_field_start(), parallel_vacuum_main(), parallel_vacuum_process_one_index(), parse_compress_specification(), parse_extension_control_file(), parse_hba_auth_opt(), parse_hba_line(), parse_ident_line(), parse_output_parameters(), parse_publication_options(), parse_scram_secret(), parse_subscription_options(), ParseConfigFp(), ParseLongOption(), parseNameAndArgTypes(), ParseTzFile(), perform_base_backup(), PerformCursorOpen(), pg_available_extension_versions(), pg_available_extensions(), pg_import_system_collations(), pg_lsn_out(), pg_split_opts(), pg_split_walfile_name(), pg_tzenumerate_next(), pg_tzenumerate_start(), pgfnames(), pgrowlocks(), pgstatindex_impl(), plperl_init_interp(), plperl_to_hstore(), plpgsql_build_recfield(), plpgsql_build_record(), plpgsql_build_variable(), plpgsql_compile_callback(), plpgsql_compile_inline(), plpgsql_extra_checks_check_hook(), plsample_func_handler(), plsample_trigger_handler(), pltcl_set_tuple_values(), PLy_output(), PLy_procedure_create(), PLyObject_AsString(), PLyUnicode_AsString(), populate_scalar(), postgresImportForeignSchema(), PostmasterMain(), pq_parse_errornotice(), precheck_tar_backup_file(), prepare_foreign_modify(), prepare_sql_fn_parse_info(), PrepareTempTablespaces(), preprocess_targetlist(), preprocessNamespacePath(), print_function_sqlbody(), process_integer_literal(), process_psqlrc(), ProcessConfigFileInternal(), ProcessParallelApplyMessage(), ProcessParallelMessage(), ProcessPgArchInterrupts(), ProcessStandbyHSFeedbackMessage(), ProcessStandbyReplyMessage(), ProcessStartupPacket(), ProcessWalSndrMessage(), prsd_headline(), prsd_lextype(), pset_value_string(), px_find_combo(), QueueFKConstraintValidation(), QueueNNConstraintValidation(), range_deparse(), read_client_final_message(), read_client_first_message(), read_dictionary(), read_tablespace_map(), RebuildConstraintComment(), record_config_file_error(), regclassout(), regcollationout(), regconfigout(), regdatabaseout(), regdictionaryout(), register_label_provider(), regnamespaceout(), regoperatorout(), regoperout(), regprocedureout(), regprocout(), REGRESS_exec_check_perms(), REGRESS_object_access_hook_str(), REGRESS_utility_command(), regroleout(), regtypeout(), ReindexPartitions(), RelationBuildTriggers(), RelationGetNotNullConstraints(), RemoveInheritance(), ReorderBufferFinishPrepared(), ReorderBufferPrepare(), ReorderBufferQueueMessage(), replace_auto_config_value(), ReplicationSlotRelease(), ReThrowError(), rewriteTargetListIU(), rewriteTargetView(), rmtree(), scram_exchange(), sendDir(), sepgsql_avc_compute(), sepgsql_compute_create(), sepgsql_get_label(), sepgsql_mcstrans_in(), sepgsql_mcstrans_out(), sepgsql_set_client_label(), set_relation_column_names(), set_stream_options(), shell_archive_file(), shell_get_sink(), show_sort_group_keys(), ShowGUCOption(), slotsync_reread_config(), SPI_fname(), SPI_getrelname(), SPI_gettype(), SplitDirectoriesString(), splitTzLine(), StartupRereadConfig(), stringToQualifiedNameList(), strip_trailing_ws(), substitute_path_macro(), SysLoggerMain(), test_rls_hooks_permissive(), test_rls_hooks_restrictive(), testprs_lextype(), textToQualifiedNameList(), thesaurus_init(), throw_tcl_error(), ThrowErrorData(), tidout(), time_out(), timestamp_out(), timestamptz_out(), timetz_out(), tokenize_auth_file(), tokenize_expand_file(), transformFkeyGetPrimaryKey(), transformIndexConstraint(), transformJsonArrayQueryConstructor(), transformJsonTableColumn(), transformJsonTableColumns(), transformRangeTableFunc(), transformRowExpr(), transformSetOperationStmt(), transformTableLikeClause(), tsearch_readline(), typeTypeName(), unknownin(), unknownout(), utf_e2u(), utf_u2e(), validate_token(), verify_plain_backup_directory(), void_out(), wait_result_to_str(), worker_spi_main(), and X509_NAME_to_cstring().

repalloc()

void * repalloc	(	void *	pointer,
		Size	size
	)

Definition at line 1632 of file mcxt.c.

{
#if defined(USE_ASSERT_CHECKING) || defined(USE_VALGRIND)
    MemoryContext context = GetMemoryChunkContext(pointer);
#endif
    void       *ret;
 
    AssertNotInCriticalSection(context);
 
    /* isReset must be false already */
    Assert(!context->isReset);
 
    /*
     * For efficiency reasons, we purposefully offload the handling of
     * allocation failures to the MemoryContextMethods implementation as this
     * allows these checks to be performed only when an actual malloc needs to
     * be done to request more memory from the OS.  Additionally, not having
     * to execute any instructions after this call allows the compiler to use
     * the sibling call optimization.  If you're considering adding code after
     * this call, consider making it the responsibility of the 'realloc'
     * function instead.
     */
    ret = MCXT_METHOD(pointer, realloc) (pointer, size, 0);
 
    VALGRIND_MEMPOOL_CHANGE(context, pointer, ret, size);
 
    return ret;
}

References Assert, AssertNotInCriticalSection, GetMemoryChunkContext(), MemoryContextData::isReset, MCXT_METHOD, realloc, and VALGRIND_MEMPOOL_CHANGE.

Referenced by _bt_deadblocks(), _bt_pendingfsm_add(), _bt_preprocess_keys(), _fdvec_resize(), accumArrayResult(), accumArrayResultArr(), add_column_to_pathtarget(), add_exact_object_address(), add_exact_object_address_extra(), add_object_address(), add_reloption(), addCompiledLexeme(), addCompoundAffixFlagValue(), AddInvalidationMessage(), addlit(), addlitchar(), AddStem(), addToArray(), AfterTriggerBeginSubXact(), AfterTriggerEnlargeQueryState(), appendElement(), appendKey(), apply_spooled_messages(), array_agg_array_combine(), array_agg_combine(), array_set_element_expanded(), AtSubCommit_childXids(), BlockRefTableEntryMarkBlockModified(), bms_add_member(), bms_add_range(), bms_replace_members(), brin_copy_tuple(), BufferSync(), BufFileAppend(), checkSharedDependencies(), compileTheLexeme(), compileTheSubstitute(), CopyReadAttributesCSV(), CopyReadAttributesText(), core_yyrealloc(), count_usable_fds(), cube_inter(), do_set_block_offsets(), dsnowball_lexize(), dxsyn_lexize(), enlarge_list(), enlargeStringInfo(), enum_range_internal(), ExecIndexBuildScanKeys(), ExecInitPartitionDispatchInfo(), ExecInitRoutingInfo(), ExprEvalPushStep(), extendBufFile(), find_inheritance_children_extended(), find_plan(), findDependentObjects(), generate_dependencies_recurse(), generateHeadline(), get_docrep(), GetComboCommandId(), GetConfFilesInDir(), GetExplainExtensionId(), GetLockStatusData(), GetPlannerExtensionId(), GetSingleProcBlockerStatusData(), GinBufferStoreTuple(), GinFormTuple(), ginPostingListDecodeAllSegments(), gistAddLoadedBuffer(), gistBuffersReleaseBlock(), gistGetNodeBuffer(), gtsvector_compress(), hladdword(), hlfinditem(), icu_language_tag(), int2vectorin(), jsonpath_yyrealloc(), load_domaintype_info(), load_enum_cache_data(), load_relcache_init_file(), LockAcquireExtended(), lookup_type_cache(), ltree_prefix_eq_ci(), ltsGetPreallocBlock(), ltsReleaseBlock(), mark_hl_fragments(), MergeAffix(), multirange_in(), NIAddAffix(), NIAddSpell(), NISortAffixes(), oidvectorin(), oidvectortypes(), okeys_object_field_start(), parse_hstore(), parsetext(), perform_default_encoding_conversion(), pg_do_encoding_conversion(), pg_import_system_collations(), pgss_shmem_startup(), plainnode(), plpgsql_adddatum(), prepare_room(), PrescanPreparedTransactions(), prs_setup_firstcall(), pushval_asis(), pushValue(), record_corrupt_item(), RecordConstLocation(), RegisterExtensionExplainOption(), RelationBuildDesc(), RelationBuildRuleLock(), RelationBuildTriggers(), RememberToFreeTupleDescAtEOX(), ReorderBufferAccumulateInvalidations(), ReorderBufferSerializeReserve(), repalloc0(), RequestNamedLWLockTranche(), resize_intArrayType(), resizeString(), rmtree(), SetConstraintStateAddItem(), setup_regexp_matches(), setup_test_matches(), SnapBuildAddCommittedTxn(), socket_putmessage_noblock(), SPI_connect_ext(), SPI_repalloc(), statext_dependencies_build(), statext_dependencies_deserialize(), statext_mcv_deserialize(), str_casefold(), str_initcap(), str_tolower(), str_toupper(), str_udeescape(), subxact_info_add(), TidListEval(), tsqueryrecv(), tsvectorin(), tsvectorrecv(), tuplestore_alloc_read_pointer(), uniqueentry(), varstr_abbrev_convert(), varstrfastcmp_locale(), XLogEnsureRecordSpace(), and yyrealloc().

repalloc0()

void * repalloc0	(	void *	pointer,
		Size	oldsize,
		Size	size
	)

Definition at line 1704 of file mcxt.c.

{
    void       *ret;
 
    /* catch wrong argument order */
    if (unlikely(oldsize > size))
        elog(ERROR, "invalid repalloc0 call: oldsize %zu, new size %zu",
             oldsize, size);
 
    ret = repalloc(pointer, size);
    memset((char *) ret + oldsize, 0, (size - oldsize));
    return ret;
}

References elog, ERROR, fb(), repalloc(), and unlikely.

Referenced by grow_notnull_info().

repalloc_extended()

void * repalloc_extended	(	void *	pointer,
		Size	size,
		int	flags
	)

Definition at line 1667 of file mcxt.c.

{
#if defined(USE_ASSERT_CHECKING) || defined(USE_VALGRIND)
    MemoryContext context = GetMemoryChunkContext(pointer);
#endif
    void       *ret;
 
    AssertNotInCriticalSection(context);
 
    /* isReset must be false already */
    Assert(!context->isReset);
 
    /*
     * For efficiency reasons, we purposefully offload the handling of
     * allocation failures to the MemoryContextMethods implementation as this
     * allows these checks to be performed only when an actual malloc needs to
     * be done to request more memory from the OS.  Additionally, not having
     * to execute any instructions after this call allows the compiler to use
     * the sibling call optimization.  If you're considering adding code after
     * this call, consider making it the responsibility of the 'realloc'
     * function instead.
     */
    ret = MCXT_METHOD(pointer, realloc) (pointer, size, flags);
    if (unlikely(ret == NULL))
        return NULL;
 
    VALGRIND_MEMPOOL_CHANGE(context, pointer, ret, size);
 
    return ret;
}

References Assert, AssertNotInCriticalSection, fb(), GetMemoryChunkContext(), MemoryContextData::isReset, MCXT_METHOD, realloc, unlikely, and VALGRIND_MEMPOOL_CHANGE.

Referenced by guc_realloc(), and repalloc_huge().

repalloc_huge()

void * repalloc_huge	(	void *	pointer,
		Size	size
	)

Definition at line 1757 of file mcxt.c.

{
    /* this one seems not worth its own implementation */
    return repalloc_extended(pointer, size, MCXT_ALLOC_HUGE);
}

References MCXT_ALLOC_HUGE, and repalloc_extended().

Referenced by ginCombineData(), grow_memtuples(), grow_memtuples(), and spi_printtup().

Variable Documentation

CacheMemoryContext

MemoryContext CacheMemoryContext = NULL

Definition at line 169 of file mcxt.c.

Referenced by _SPI_save_plan(), AllocateRelationDesc(), assign_record_type_typmod(), AttrDefaultFetch(), BuildEventTriggerCache(), BuildHardcodedDescriptor(), CatalogCacheCreateEntry(), CatalogCacheInitializeCache(), CheckNNConstraintFetch(), CreateCacheMemoryContext(), ensure_record_cache_typmod_slot_exists(), FetchRelationStates(), generate_partition_qual(), get_attribute_options(), get_tablespace(), GetCachedExpression(), GetCachedPlan(), GetFdwRoutineForRelation(), init_ts_config_cache(), InitCatCache(), InitializeAttoptCache(), InitializeRelfilenumberMap(), InitializeTableSpaceCache(), load_domaintype_info(), load_enum_cache_data(), load_rangetype_info(), load_relcache_init_file(), logicalrep_partmap_init(), logicalrep_relmap_init(), lookup_ts_config_cache(), lookup_ts_dictionary_cache(), lookup_ts_parser_cache(), lookup_type_cache(), LookupOpclassInfo(), pgoutput_startup(), plpgsql_compile_callback(), register_on_commit_action(), RehashCatCache(), RehashCatCacheLists(), RelationBuildLocalRelation(), RelationBuildPartitionDesc(), RelationBuildPartitionKey(), RelationBuildPublicationDesc(), RelationBuildRowSecurity(), RelationBuildRuleLock(), RelationBuildTriggers(), RelationBuildTupleDesc(), RelationCacheInitialize(), RelationCacheInitializePhase2(), RelationCacheInitializePhase3(), RelationGetFKeyList(), RelationGetIdentityKeyBitmap(), RelationGetIndexAttrBitmap(), RelationGetIndexList(), RelationGetStatExtList(), RelationInitIndexAccessInfo(), RelationParseRelOptions(), RememberToFreeTupleDescAtEOX(), SaveCachedPlan(), SearchCatCacheList(), set_schema_sent_in_streamed_txn(), SPI_keepplan(), sql_compile_callback(), and UploadManifest().

CurrentMemoryContext

MemoryContext CurrentMemoryContext = NULL

Definition at line 160 of file mcxt.c.

Referenced by _brin_parallel_merge(), _bt_load(), _bt_preprocess_array_keys(), _gin_parallel_build_main(), _hash_finish_split(), _SPI_commit(), _SPI_rollback(), _SPI_save_plan(), advance_windowaggregate(), advance_windowaggregate_base(), afterTriggerInvokeEvents(), AllocateSnapshotBuilder(), array_agg_array_deserialize(), array_agg_array_finalfn(), array_agg_deserialize(), array_agg_finalfn(), array_positions(), array_sort_internal(), array_to_datum_internal(), AtStart_Memory(), AtSubStart_Memory(), AttachPartitionEnsureIndexes(), autovacuum_do_vac_analyze(), be_lo_export(), be_lo_from_bytea(), be_lo_put(), begin_heap_rewrite(), BeginCopyFrom(), BeginCopyTo(), blbuild(), blinsert(), brin_build_desc(), brin_minmax_multi_summary_out(), brin_minmax_multi_union(), brin_new_memtuple(), bringetbitmap(), brininsert(), bt_check_every_level(), btree_xlog_startup(), btvacuumscan(), build_colinfo_names_hash(), build_join_rel_hash(), BuildCachedPlan(), BuildParamLogString(), BuildRelationExtStatistics(), CheckForSessionAndXactLocks(), CloneRowTriggersToPartition(), CompactCheckpointerRequestQueue(), compactify_ranges(), CompleteCachedPlan(), compute_array_stats(), compute_expr_stats(), compute_scalar_stats(), compute_tsvector_stats(), ComputeExtStatisticsRows(), CopyCachedPlan(), CopyErrorData(), CopyFrom(), CopyFromTextLikeOneRow(), create_toast_table(), CreateCachedPlan(), CreateEmptyBlockRefTable(), CreateExecutorState(), CreateOneShotCachedPlan(), CreatePartitionPruneState(), CreateStandaloneExprContext(), createTempGistContext(), createTrgmNFA(), CreateTriggerFiringOn(), daitch_mokotoff(), daitch_mokotoff_coding(), DatumGetExpandedArray(), DatumGetExpandedArrayX(), DatumGetExpandedRecord(), datumTransfer(), dblink_get_connections(), DiscreteKnapsack(), do_analyze_rel(), do_start_worker(), DoCopyTo(), domain_check_internal(), dsnowball_init(), each_worker(), each_worker_jsonb(), elements_worker(), elements_worker_jsonb(), ensure_free_space_in_buffer(), eqjoinsel_find_matches(), errsave_start(), EventTriggerInvoke(), examine_expression(), exec_replication_command(), exec_stmt_block(), ExecAggCopyTransValue(), ExecEvalHashedScalarArrayOp(), ExecHashTableCreate(), ExecInitCoerceToDomain(), ExecInitFunctionScan(), ExecInitGatherMerge(), ExecInitIndexScan(), ExecInitMemoize(), ExecInitMergeAppend(), ExecInitModifyTable(), ExecInitProjectSet(), ExecInitRecursiveUnion(), ExecInitSetOp(), ExecInitSubPlan(), ExecInitTableFuncScan(), ExecInitWindowAgg(), ExecMakeTableFunctionResult(), ExecScanSubPlan(), ExecSetParamPlan(), ExecSetupPartitionTupleRouting(), execute_sql_string(), ExecuteTruncateGuts(), ExplainExecuteQuery(), fetch_array_arg_replace_nulls(), file_acquire_sample_rows(), fileIterateForeignScan(), fill_hba_view(), fill_ident_view(), find_all_inheritors(), find_or_create_child_node(), find_partition_scheme(), fmgr_info(), fmgr_info_other_lang(), geqo_eval(), get_actual_variable_range(), get_database_list(), get_json_object_as_hash(), get_relation_notnullatts(), get_subscription_list(), GetCachedExpression(), GetConnection(), GetErrorContextStack(), GetWALRecordsInfo(), GetXLogSummaryStats(), gin_check_parent_keys_consistency(), gin_check_posting_tree_parent_keys_consistency(), gin_extract_query_trgm(), gin_xlog_startup(), ginbeginscan(), GinBufferInit(), ginbuild(), ginbulkdelete(), gininsert(), ginInsertCleanup(), ginPlaceToPage(), gistbuild(), gistInitBuildBuffers(), gistInitParentMap(), gistvacuumscan(), IdentifySystem(), index_form_tuple(), initBloomState(), initGinState(), initGISTstate(), initialize_brin_buildstate(), initialize_peragg(), InitPartitionPruneContext(), initTrie(), inline_function(), inline_function_in_from(), intset_create(), json_unique_builder_init(), json_unique_check_init(), JsonTableInitOpaque(), libpqrcv_processTuples(), libpqsrv_PQwrap(), lo_get_fragment_internal(), lo_import_internal(), load_domaintype_info(), load_tzoffsets(), load_validator_library(), LogicalParallelApplyLoop(), makeIndexInfo(), makeNumericAggStateCurrentContext(), MakeTupleTableSlot(), materializeQueryResult(), MemoryContextDeleteOnly(), MemoryContextInit(), MemoryContextSwitchTo(), MJExamineQuals(), multi_sort_add_dimension(), NextCopyFrom(), open_auth_file(), optionListToArray(), palloc(), palloc0(), palloc_aligned(), palloc_extended(), ParallelWorkerMain(), parse_ident(), perform_default_encoding_conversion(), perform_work_item(), pg_buffercache_os_pages_internal(), pg_buffercache_pages(), pg_do_encoding_conversion(), pg_get_backend_memory_contexts(), pg_get_logical_snapshot_info(), pg_get_logical_snapshot_meta(), pg_get_statisticsobjdef_expressions(), pg_get_wal_block_info(), pg_stats_ext_mcvlist_items(), plan_cluster_use_sort(), plan_create_index_workers(), plperl_array_to_datum(), plperl_inline_handler(), plperl_return_next(), plperl_return_next_internal(), plperl_spi_commit(), plperl_spi_exec(), plperl_spi_exec_prepared(), plperl_spi_fetchrow(), plperl_spi_prepare(), plperl_spi_query(), plperl_spi_query_prepared(), plperl_spi_rollback(), plperl_util_elog(), plpgsql_compile_callback(), plpgsql_compile_inline(), plpgsql_estate_setup(), plpgsql_inline_handler(), plpgsql_validator(), plpython3_inline_handler(), pltcl_commit(), pltcl_elog(), pltcl_returnnext(), pltcl_rollback(), pltcl_SPI_execute(), pltcl_SPI_execute_plan(), pltcl_SPI_prepare(), pltcl_subtransaction(), PLy_commit(), PLy_cursor_fetch(), PLy_cursor_iternext(), PLy_cursor_plan(), PLy_cursor_query(), PLy_output(), PLy_rollback(), PLy_spi_execute_fetch_result(), PLy_spi_execute_plan(), PLy_spi_execute_query(), PLy_spi_prepare(), PLy_subtransaction_enter(), PLySequence_ToArray(), PLySequence_ToArray_recurse(), populate_array(), populate_recordset_object_start(), PortalRun(), PortalRunMulti(), postgresAcquireSampleRowsFunc(), postquel_start(), pq_parse_errornotice(), preparePresortedCols(), printtup_startup(), ProcessConfigFile(), prune_append_rel_partitions(), pstrdup(), publicationListToArray(), pull_up_simple_subquery(), pushJsonbValueScalar(), pushState(), RE_compile_and_cache(), regexp_split_to_array(), RelationBuildDesc(), RelationBuildRowSecurity(), ReorderBufferAllocate(), ReorderBufferImmediateInvalidation(), ReorderBufferProcessTXN(), ResetUnloggedRelations(), ResetUnloggedRelationsInDbspaceDir(), RevalidateCachedQuery(), ScanKeyEntryInitializeWithInfo(), serialize_expr_stats(), serializeAnalyzeStartup(), SerializePendingSyncs(), set_relation_partition_info(), set_rtable_names(), shdepReassignOwned(), shm_mq_attach(), smgr_bulk_start_smgr(), spg_xlog_startup(), spgbeginscan(), spgbuild(), spginsert(), spi_dest_startup(), split_text_accum_result(), sql_compile_callback(), standard_ExplainOneQuery(), startScanKey(), StartupDecodingContext(), statext_dependencies_build(), statext_mcv_serialize(), strlist_to_textarray(), sts_attach(), sts_initialize(), subquery_planner(), tbm_create(), test_basic(), test_empty(), test_enc_conversion(), test_pattern(), test_random(), text_to_array(), TidStoreCreateLocal(), tokenize_auth_file(), transformGraph(), transformRelOptions(), tsquery_rewrite_query(), tuple_data_split_internal(), tuplesort_begin_cluster(), tuplesort_begin_common(), tuplesort_begin_datum(), tuplesort_begin_heap(), tuplesort_begin_index_btree(), tuplesort_begin_index_gin(), tuplesort_begin_index_gist(), tuplestore_begin_common(), union_tuples(), UploadManifest(), validateForeignKeyConstraint(), write_console(), and xpath().

CurTransactionContext

MemoryContext CurTransactionContext = NULL

Definition at line 172 of file mcxt.c.

Referenced by AddEventToPendingNotifies(), Async_Notify(), AtCleanup_Memory(), AtCommit_Memory(), AtStart_Memory(), AtSubCleanup_Memory(), AtSubCommit_Memory(), AtSubStart_Memory(), GetAfterTriggersStoreSlot(), GetAfterTriggersTableData(), GetCurrentFDWTuplestore(), initPendingListenActions(), MakeTransitionCaptureState(), NIStartBuild(), PLy_cursor_plan(), PLy_spi_execute_plan(), PopTransaction(), queue_listen(), RelationBuildPartitionDesc(), RelationBuildPartitionKey(), ReleaseCurrentSubTransaction(), sepgsql_set_client_label(), setup_background_workers(), StartTransactionCommand(), and xactGetCommittedInvalidationMessages().

ErrorContext

MemoryContext ErrorContext = NULL

Definition at line 167 of file mcxt.c.

Referenced by CopyErrorData(), errfinish(), errstart(), FlushErrorState(), format_elog_string(), MemoryContextInit(), and ReThrowError().

LogMemoryContextInProgress

bool LogMemoryContextInProgress = false

static

Definition at line 178 of file mcxt.c.

Referenced by ProcessLogMemoryContextInterrupt().

mcxt_methods

const MemoryContextMethods mcxt_methods[]

static

Definition at line 63 of file mcxt.c.

                                                   {
    /* aset.c */
    [MCTX_ASET_ID].alloc = AllocSetAlloc,
    [MCTX_ASET_ID].free_p = AllocSetFree,
    [MCTX_ASET_ID].realloc = AllocSetRealloc,
    [MCTX_ASET_ID].reset = AllocSetReset,
    [MCTX_ASET_ID].delete_context = AllocSetDelete,
    [MCTX_ASET_ID].get_chunk_context = AllocSetGetChunkContext,
    [MCTX_ASET_ID].get_chunk_space = AllocSetGetChunkSpace,
    [MCTX_ASET_ID].is_empty = AllocSetIsEmpty,
    [MCTX_ASET_ID].stats = AllocSetStats,
#ifdef MEMORY_CONTEXT_CHECKING
    [MCTX_ASET_ID].check = AllocSetCheck,
#endif
 
    /* generation.c */
    [MCTX_GENERATION_ID].alloc = GenerationAlloc,
    [MCTX_GENERATION_ID].free_p = GenerationFree,
    [MCTX_GENERATION_ID].realloc = GenerationRealloc,
    [MCTX_GENERATION_ID].reset = GenerationReset,
    [MCTX_GENERATION_ID].delete_context = GenerationDelete,
    [MCTX_GENERATION_ID].get_chunk_context = GenerationGetChunkContext,
    [MCTX_GENERATION_ID].get_chunk_space = GenerationGetChunkSpace,
    [MCTX_GENERATION_ID].is_empty = GenerationIsEmpty,
    [MCTX_GENERATION_ID].stats = GenerationStats,
#ifdef MEMORY_CONTEXT_CHECKING
    [MCTX_GENERATION_ID].check = GenerationCheck,
#endif
 
    /* slab.c */
    [MCTX_SLAB_ID].alloc = SlabAlloc,
    [MCTX_SLAB_ID].free_p = SlabFree,
    [MCTX_SLAB_ID].realloc = SlabRealloc,
    [MCTX_SLAB_ID].reset = SlabReset,
    [MCTX_SLAB_ID].delete_context = SlabDelete,
    [MCTX_SLAB_ID].get_chunk_context = SlabGetChunkContext,
    [MCTX_SLAB_ID].get_chunk_space = SlabGetChunkSpace,
    [MCTX_SLAB_ID].is_empty = SlabIsEmpty,
    [MCTX_SLAB_ID].stats = SlabStats,
#ifdef MEMORY_CONTEXT_CHECKING
    [MCTX_SLAB_ID].check = SlabCheck,
#endif
 
    /* alignedalloc.c */
    [MCTX_ALIGNED_REDIRECT_ID].alloc = NULL,    /* not required */
    [MCTX_ALIGNED_REDIRECT_ID].free_p = AlignedAllocFree,
    [MCTX_ALIGNED_REDIRECT_ID].realloc = AlignedAllocRealloc,
    [MCTX_ALIGNED_REDIRECT_ID].reset = NULL,    /* not required */
    [MCTX_ALIGNED_REDIRECT_ID].delete_context = NULL,   /* not required */
    [MCTX_ALIGNED_REDIRECT_ID].get_chunk_context = AlignedAllocGetChunkContext,
    [MCTX_ALIGNED_REDIRECT_ID].get_chunk_space = AlignedAllocGetChunkSpace,
    [MCTX_ALIGNED_REDIRECT_ID].is_empty = NULL, /* not required */
    [MCTX_ALIGNED_REDIRECT_ID].stats = NULL,    /* not required */
#ifdef MEMORY_CONTEXT_CHECKING
    [MCTX_ALIGNED_REDIRECT_ID].check = NULL,    /* not required */
#endif
 
    /* bump.c */
    [MCTX_BUMP_ID].alloc = BumpAlloc,
    [MCTX_BUMP_ID].free_p = BumpFree,
    [MCTX_BUMP_ID].realloc = BumpRealloc,
    [MCTX_BUMP_ID].reset = BumpReset,
    [MCTX_BUMP_ID].delete_context = BumpDelete,
    [MCTX_BUMP_ID].get_chunk_context = BumpGetChunkContext,
    [MCTX_BUMP_ID].get_chunk_space = BumpGetChunkSpace,
    [MCTX_BUMP_ID].is_empty = BumpIsEmpty,
    [MCTX_BUMP_ID].stats = BumpStats,
#ifdef MEMORY_CONTEXT_CHECKING
    [MCTX_BUMP_ID].check = BumpCheck,
#endif
 
 
    /*
     * Reserved and unused IDs should have dummy entries here.  This allows us
     * to fail cleanly if a bogus pointer is passed to pfree or the like.  It
     * seems sufficient to provide routines for the methods that might get
     * invoked from inspection of a chunk (see MCXT_METHOD calls below).
     */
    BOGUS_MCTX(MCTX_1_RESERVED_GLIBC_ID),
    BOGUS_MCTX(MCTX_2_RESERVED_GLIBC_ID),
    BOGUS_MCTX(MCTX_8_UNUSED_ID),
    BOGUS_MCTX(MCTX_9_UNUSED_ID),
    BOGUS_MCTX(MCTX_10_UNUSED_ID),
    BOGUS_MCTX(MCTX_11_UNUSED_ID),
    BOGUS_MCTX(MCTX_12_UNUSED_ID),
    BOGUS_MCTX(MCTX_13_UNUSED_ID),
    BOGUS_MCTX(MCTX_14_UNUSED_ID),
    BOGUS_MCTX(MCTX_0_RESERVED_UNUSEDMEM_ID),
    BOGUS_MCTX(MCTX_15_RESERVED_WIPEDMEM_ID)
};

Referenced by MemoryContextCreate().

MessageContext

MemoryContext MessageContext = NULL

Definition at line 170 of file mcxt.c.

Referenced by exec_bind_message(), exec_describe_portal_message(), exec_describe_statement_message(), exec_parse_message(), exec_simple_query(), and PostgresMain().

PortalContext

MemoryContext PortalContext = NULL

Definition at line 175 of file mcxt.c.

Referenced by ATExecDetachPartition(), cluster(), do_autovacuum(), ExecVacuum(), perform_work_item(), PersistHoldablePortal(), PLy_push_execution_context(), PortalRun(), PortalRunFetch(), PortalStart(), ReindexMultipleTables(), ReindexPartitions(), ReindexRelationConcurrently(), and SPI_connect_ext().

PostmasterContext

MemoryContext PostmasterContext = NULL

Definition at line 168 of file mcxt.c.

Referenced by AutoVacLauncherMain(), AutoVacWorkerMain(), AuxiliaryProcessMainCommon(), BackgroundWorkerMain(), BackgroundWorkerStateChange(), load_hba(), load_ident(), PerformAuthentication(), PostgresMain(), PostmasterMain(), RegisterBackgroundWorker(), and SysLoggerMain().

TopMemoryContext

MemoryContext TopMemoryContext = NULL

Definition at line 166 of file mcxt.c.

Referenced by _PG_init(), AbortOutOfAnyTransaction(), add_reloption(), allocate_reloption(), AllocateAttribute(), AllocSetContextCreateInternal(), ApplyLauncherMain(), AtAbort_Memory(), AtStart_Memory(), AttachSession(), AutoVacLauncherMain(), BackendInitialize(), BackendMain(), BackgroundWorkerMain(), BackgroundWriterMain(), BaseBackupAddTarget(), be_tls_open_server(), build_guc_variables(), BumpContextCreate(), cache_single_string(), cached_function_compile(), cfunc_hashtable_insert(), check_foreign_key(), check_primary_key(), CheckpointerMain(), ClientAuthentication(), compile_plperl_function(), compile_pltcl_function(), CreateCacheMemoryContext(), CreateWaitEventSet(), dblink_init(), DCH_cache_getnew(), do_autovacuum(), dsm_create_descriptor(), dsm_impl_sysv(), EnablePortalManager(), EventTriggerBeginCompleteQuery(), exec_replication_command(), executeDateTimeMethod(), find_plan(), finish_xact_command(), GenerationContextCreate(), GetExplainExtensionId(), GetLocalBufferStorage(), GetLockConflicts(), getmissingattr(), GetNamedDSA(), GetNamedDSHash(), GetNamedDSMSegment(), GetPlannerExtensionId(), GetSessionDsmHandle(), hash_create(), init_database_collation(), init_missing_cache(), init_string_reloption(), InitDeadLockChecking(), initGlobalChannelTable(), initialize_reloptions(), initialize_target_list(), InitializeClientEncoding(), InitializeLogRepWorker(), InitializeParallelDSM(), InitializeSearchPath(), InitializeSession(), InitializeSystemUser(), InitPgFdwOptions(), InitSync(), InitWalSender(), InitXLogInsert(), injection_points_attach(), injection_points_detach(), llvm_compile_module(), llvm_create_context(), llvm_session_initialize(), LockAcquireExtended(), logicalrep_launcher_attach_dshmem(), LogicalRepApplyLoop(), mdinit(), MemoryContextAllocationFailure(), MemoryContextDeleteOnly(), MemoryContextInit(), mxid_to_string(), newLOfd(), NUM_cache_getnew(), on_dsm_detach(), PageSetChecksumCopy(), ParallelWorkerMain(), PerformAuthentication(), pg_backup_start(), pg_get_backend_memory_contexts(), pg_get_dsm_registry_allocations(), pg_newlocale_from_collation(), PgArchiverMain(), pgstat_attach_shmem(), pgstat_init_snapshot_fixed(), pgstat_prep_pending_entry(), pgstat_prep_snapshot(), pgstat_register_kind(), pgstat_setup_backend_status_context(), pgstat_setup_memcxt(), plperl_spi_prepare(), plpython3_inline_handler(), plsample_func_handler(), pltcl_SPI_prepare(), PLy_cursor_plan(), PLy_cursor_query(), PLy_procedure_create(), PLy_spi_execute_fetch_result(), PLy_spi_prepare(), populate_typ_list(), PostgresMain(), postmaster_child_launch(), PostmasterMain(), pq_init(), PreCommit_Notify(), PrepareClientEncoding(), ProcessLogMemoryContextInterrupt(), ProcessParallelApplyMessages(), ProcessParallelMessages(), ProcessStartupPacket(), px_find_cipher(), px_find_digest(), RE_compile_and_cache(), recomputeNamespacePath(), register_label_provider(), RegisterExtensionExplainOption(), RegisterResourceReleaseCallback(), RegisterSubXactCallback(), RegisterXactCallback(), RelationCreateStorage(), RelationDropStorage(), RequestNamedLWLockTranche(), ResourceOwnerCreate(), ResourceOwnerEnlarge(), RestoreClientConnectionInfo(), RestoreReindexState(), ri_HashCompareOp(), roles_is_member_of(), secure_open_gssapi(), sepgsql_avc_init(), sepgsql_xact_callback(), set_authn_id(), SetDatabasePath(), SharedRecordTypmodRegistryAttach(), SharedRecordTypmodRegistryInit(), SlabContextCreate(), spcache_init(), SPI_connect_ext(), test_create(), WalSummarizerMain(), WalWriterMain(), and XLOGShmemInit().

TopTransactionContext

MemoryContext TopTransactionContext = NULL

Definition at line 171 of file mcxt.c.

Referenced by add_tabstat_xact_level(), AddInvalidationMessage(), AddPendingSync(), afterTriggerAddEvent(), AfterTriggerBeginSubXact(), AfterTriggerEnlargeQueryState(), apply_spooled_messages(), Async_Notify(), AtCleanup_Memory(), AtCommit_Memory(), AtStart_Memory(), AtSubCommit_childXids(), BeginInternalSubTransaction(), CopySnapshot(), create_drop_transactional_internal(), CreateParallelContext(), DefineSavepoint(), do_autovacuum(), ExportSnapshot(), GetComboCommandId(), init_uncommitted_enum_types(), init_uncommitted_enum_values(), InitializeParallelDSM(), LaunchParallelWorkers(), LogicalRepWorkersWakeupAtCommit(), make_tuple_indirect(), mXactCachePut(), pa_start_subtrans(), pgstat_get_xact_stack_level(), plpgsql_create_econtext(), PLy_get_scratch_context(), PLy_push_execution_context(), PLy_subtransaction_enter(), PortalRun(), PrepareInvalidationState(), PrepareTempTablespaces(), PrepareTransactionBlock(), push_old_value(), PushActiveSnapshotWithLevel(), PushTransaction(), queue_listen(), ReinitializeParallelDSM(), RestoreSnapshot(), SetConstraintStateCreate(), setup_background_workers(), and SPI_connect_ext().