LCOV - code coverage report
Current view: top level - src/backend/utils/mmgr - mcxt.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 260 321 81.0 %
Date: 2024-05-19 09:11:23 Functions: 43 52 82.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * mcxt.c
       4             :  *    POSTGRES memory context management code.
       5             :  *
       6             :  * This module handles context management operations that are independent
       7             :  * of the particular kind of context being operated on.  It calls
       8             :  * context-type-specific operations via the function pointers in a
       9             :  * context's MemoryContextMethods struct.
      10             :  *
      11             :  *
      12             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
      13             :  * Portions Copyright (c) 1994, Regents of the University of California
      14             :  *
      15             :  *
      16             :  * IDENTIFICATION
      17             :  *    src/backend/utils/mmgr/mcxt.c
      18             :  *
      19             :  *-------------------------------------------------------------------------
      20             :  */
      21             : 
      22             : #include "postgres.h"
      23             : 
      24             : #include "mb/pg_wchar.h"
      25             : #include "miscadmin.h"
      26             : #include "utils/memdebug.h"
      27             : #include "utils/memutils.h"
      28             : #include "utils/memutils_internal.h"
      29             : #include "utils/memutils_memorychunk.h"
      30             : 
      31             : 
      32             : static void BogusFree(void *pointer);
      33             : static void *BogusRealloc(void *pointer, Size size, int flags);
      34             : static MemoryContext BogusGetChunkContext(void *pointer);
      35             : static Size BogusGetChunkSpace(void *pointer);
      36             : 
      37             : /*****************************************************************************
      38             :  *    GLOBAL MEMORY                                                          *
      39             :  *****************************************************************************/
      40             : #define BOGUS_MCTX(id) \
      41             :     [id].free_p = BogusFree, \
      42             :     [id].realloc = BogusRealloc, \
      43             :     [id].get_chunk_context = BogusGetChunkContext, \
      44             :     [id].get_chunk_space = BogusGetChunkSpace
      45             : 
      46             : static const MemoryContextMethods mcxt_methods[] = {
      47             :     /* aset.c */
      48             :     [MCTX_ASET_ID].alloc = AllocSetAlloc,
      49             :     [MCTX_ASET_ID].free_p = AllocSetFree,
      50             :     [MCTX_ASET_ID].realloc = AllocSetRealloc,
      51             :     [MCTX_ASET_ID].reset = AllocSetReset,
      52             :     [MCTX_ASET_ID].delete_context = AllocSetDelete,
      53             :     [MCTX_ASET_ID].get_chunk_context = AllocSetGetChunkContext,
      54             :     [MCTX_ASET_ID].get_chunk_space = AllocSetGetChunkSpace,
      55             :     [MCTX_ASET_ID].is_empty = AllocSetIsEmpty,
      56             :     [MCTX_ASET_ID].stats = AllocSetStats,
      57             : #ifdef MEMORY_CONTEXT_CHECKING
      58             :     [MCTX_ASET_ID].check = AllocSetCheck,
      59             : #endif
      60             : 
      61             :     /* generation.c */
      62             :     [MCTX_GENERATION_ID].alloc = GenerationAlloc,
      63             :     [MCTX_GENERATION_ID].free_p = GenerationFree,
      64             :     [MCTX_GENERATION_ID].realloc = GenerationRealloc,
      65             :     [MCTX_GENERATION_ID].reset = GenerationReset,
      66             :     [MCTX_GENERATION_ID].delete_context = GenerationDelete,
      67             :     [MCTX_GENERATION_ID].get_chunk_context = GenerationGetChunkContext,
      68             :     [MCTX_GENERATION_ID].get_chunk_space = GenerationGetChunkSpace,
      69             :     [MCTX_GENERATION_ID].is_empty = GenerationIsEmpty,
      70             :     [MCTX_GENERATION_ID].stats = GenerationStats,
      71             : #ifdef MEMORY_CONTEXT_CHECKING
      72             :     [MCTX_GENERATION_ID].check = GenerationCheck,
      73             : #endif
      74             : 
      75             :     /* slab.c */
      76             :     [MCTX_SLAB_ID].alloc = SlabAlloc,
      77             :     [MCTX_SLAB_ID].free_p = SlabFree,
      78             :     [MCTX_SLAB_ID].realloc = SlabRealloc,
      79             :     [MCTX_SLAB_ID].reset = SlabReset,
      80             :     [MCTX_SLAB_ID].delete_context = SlabDelete,
      81             :     [MCTX_SLAB_ID].get_chunk_context = SlabGetChunkContext,
      82             :     [MCTX_SLAB_ID].get_chunk_space = SlabGetChunkSpace,
      83             :     [MCTX_SLAB_ID].is_empty = SlabIsEmpty,
      84             :     [MCTX_SLAB_ID].stats = SlabStats,
      85             : #ifdef MEMORY_CONTEXT_CHECKING
      86             :     [MCTX_SLAB_ID].check = SlabCheck,
      87             : #endif
      88             : 
      89             :     /* alignedalloc.c */
      90             :     [MCTX_ALIGNED_REDIRECT_ID].alloc = NULL,    /* not required */
      91             :     [MCTX_ALIGNED_REDIRECT_ID].free_p = AlignedAllocFree,
      92             :     [MCTX_ALIGNED_REDIRECT_ID].realloc = AlignedAllocRealloc,
      93             :     [MCTX_ALIGNED_REDIRECT_ID].reset = NULL,    /* not required */
      94             :     [MCTX_ALIGNED_REDIRECT_ID].delete_context = NULL,   /* not required */
      95             :     [MCTX_ALIGNED_REDIRECT_ID].get_chunk_context = AlignedAllocGetChunkContext,
      96             :     [MCTX_ALIGNED_REDIRECT_ID].get_chunk_space = AlignedAllocGetChunkSpace,
      97             :     [MCTX_ALIGNED_REDIRECT_ID].is_empty = NULL, /* not required */
      98             :     [MCTX_ALIGNED_REDIRECT_ID].stats = NULL,    /* not required */
      99             : #ifdef MEMORY_CONTEXT_CHECKING
     100             :     [MCTX_ALIGNED_REDIRECT_ID].check = NULL,    /* not required */
     101             : #endif
     102             : 
     103             :     /* bump.c */
     104             :     [MCTX_BUMP_ID].alloc = BumpAlloc,
     105             :     [MCTX_BUMP_ID].free_p = BumpFree,
     106             :     [MCTX_BUMP_ID].realloc = BumpRealloc,
     107             :     [MCTX_BUMP_ID].reset = BumpReset,
     108             :     [MCTX_BUMP_ID].delete_context = BumpDelete,
     109             :     [MCTX_BUMP_ID].get_chunk_context = BumpGetChunkContext,
     110             :     [MCTX_BUMP_ID].get_chunk_space = BumpGetChunkSpace,
     111             :     [MCTX_BUMP_ID].is_empty = BumpIsEmpty,
     112             :     [MCTX_BUMP_ID].stats = BumpStats,
     113             : #ifdef MEMORY_CONTEXT_CHECKING
     114             :     [MCTX_BUMP_ID].check = BumpCheck,
     115             : #endif
     116             : 
     117             : 
     118             :     /*
     119             :      * Reserved and unused IDs should have dummy entries here.  This allows us
     120             :      * to fail cleanly if a bogus pointer is passed to pfree or the like.  It
     121             :      * seems sufficient to provide routines for the methods that might get
     122             :      * invoked from inspection of a chunk (see MCXT_METHOD calls below).
     123             :      */
     124             :     BOGUS_MCTX(MCTX_1_RESERVED_GLIBC_ID),
     125             :     BOGUS_MCTX(MCTX_2_RESERVED_GLIBC_ID),
     126             :     BOGUS_MCTX(MCTX_8_UNUSED_ID),
     127             :     BOGUS_MCTX(MCTX_9_UNUSED_ID),
     128             :     BOGUS_MCTX(MCTX_10_UNUSED_ID),
     129             :     BOGUS_MCTX(MCTX_11_UNUSED_ID),
     130             :     BOGUS_MCTX(MCTX_12_UNUSED_ID),
     131             :     BOGUS_MCTX(MCTX_13_UNUSED_ID),
     132             :     BOGUS_MCTX(MCTX_14_UNUSED_ID),
     133             :     BOGUS_MCTX(MCTX_0_RESERVED_UNUSEDMEM_ID),
     134             :     BOGUS_MCTX(MCTX_15_RESERVED_WIPEDMEM_ID)
     135             : };
     136             : 
     137             : #undef BOGUS_MCTX
     138             : 
     139             : /*
     140             :  * CurrentMemoryContext
     141             :  *      Default memory context for allocations.
     142             :  */
     143             : MemoryContext CurrentMemoryContext = NULL;
     144             : 
     145             : /*
     146             :  * Standard top-level contexts. For a description of the purpose of each
     147             :  * of these contexts, refer to src/backend/utils/mmgr/README
     148             :  */
     149             : MemoryContext TopMemoryContext = NULL;
     150             : MemoryContext ErrorContext = NULL;
     151             : MemoryContext PostmasterContext = NULL;
     152             : MemoryContext CacheMemoryContext = NULL;
     153             : MemoryContext MessageContext = NULL;
     154             : MemoryContext TopTransactionContext = NULL;
     155             : MemoryContext CurTransactionContext = NULL;
     156             : 
     157             : /* This is a transient link to the active portal's memory context: */
     158             : MemoryContext PortalContext = NULL;
     159             : 
     160             : static void MemoryContextDeleteOnly(MemoryContext context);
     161             : static void MemoryContextCallResetCallbacks(MemoryContext context);
     162             : static void MemoryContextStatsInternal(MemoryContext context, int level,
     163             :                                        int max_level, int max_children,
     164             :                                        MemoryContextCounters *totals,
     165             :                                        bool print_to_stderr);
     166             : static void MemoryContextStatsPrint(MemoryContext context, void *passthru,
     167             :                                     const char *stats_string,
     168             :                                     bool print_to_stderr);
     169             : 
     170             : /*
     171             :  * You should not do memory allocations within a critical section, because
     172             :  * an out-of-memory error will be escalated to a PANIC. To enforce that
     173             :  * rule, the allocation functions Assert that.
     174             :  */
     175             : #define AssertNotInCriticalSection(context) \
     176             :     Assert(CritSectionCount == 0 || (context)->allowInCritSection)
     177             : 
     178             : /*
     179             :  * Call the given function in the MemoryContextMethods for the memory context
     180             :  * type that 'pointer' belongs to.
     181             :  */
     182             : #define MCXT_METHOD(pointer, method) \
     183             :     mcxt_methods[GetMemoryChunkMethodID(pointer)].method
     184             : 
     185             : /*
     186             :  * GetMemoryChunkMethodID
     187             :  *      Return the MemoryContextMethodID from the uint64 chunk header which
     188             :  *      directly precedes 'pointer'.
     189             :  */
     190             : static inline MemoryContextMethodID
     191   427833888 : GetMemoryChunkMethodID(const void *pointer)
     192             : {
     193             :     uint64      header;
     194             : 
     195             :     /*
     196             :      * Try to detect bogus pointers handed to us, poorly though we can.
     197             :      * Presumably, a pointer that isn't MAXALIGNED isn't pointing at an
     198             :      * allocated chunk.
     199             :      */
     200             :     Assert(pointer == (const void *) MAXALIGN(pointer));
     201             : 
     202             :     /* Allow access to the uint64 header */
     203             :     VALGRIND_MAKE_MEM_DEFINED((char *) pointer - sizeof(uint64), sizeof(uint64));
     204             : 
     205   427833888 :     header = *((const uint64 *) ((const char *) pointer - sizeof(uint64)));
     206             : 
     207             :     /* Disallow access to the uint64 header */
     208             :     VALGRIND_MAKE_MEM_NOACCESS((char *) pointer - sizeof(uint64), sizeof(uint64));
     209             : 
     210   427833888 :     return (MemoryContextMethodID) (header & MEMORY_CONTEXT_METHODID_MASK);
     211             : }
     212             : 
     213             : /*
     214             :  * GetMemoryChunkHeader
     215             :  *      Return the uint64 chunk header which directly precedes 'pointer'.
     216             :  *
     217             :  * This is only used after GetMemoryChunkMethodID, so no need for error checks.
     218             :  */
     219             : static inline uint64
     220           0 : GetMemoryChunkHeader(const void *pointer)
     221             : {
     222             :     uint64      header;
     223             : 
     224             :     /* Allow access to the uint64 header */
     225             :     VALGRIND_MAKE_MEM_DEFINED((char *) pointer - sizeof(uint64), sizeof(uint64));
     226             : 
     227           0 :     header = *((const uint64 *) ((const char *) pointer - sizeof(uint64)));
     228             : 
     229             :     /* Disallow access to the uint64 header */
     230             :     VALGRIND_MAKE_MEM_NOACCESS((char *) pointer - sizeof(uint64), sizeof(uint64));
     231             : 
     232           0 :     return header;
     233             : }
     234             : 
     235             : /*
     236             :  * MemoryContextTraverseNext
     237             :  *      Helper function to traverse all descendants of a memory context
     238             :  *      without recursion.
     239             :  *
     240             :  * Recursion could lead to out-of-stack errors with deep context hierarchies,
     241             :  * which would be unpleasant in error cleanup code paths.
     242             :  *
     243             :  * To process 'context' and all its descendants, use a loop like this:
     244             :  *
     245             :  *     <process 'context'>
     246             :  *     for (MemoryContext curr = context->firstchild;
     247             :  *          curr != NULL;
     248             :  *          curr = MemoryContextTraverseNext(curr, context))
     249             :  *     {
     250             :  *         <process 'curr'>
     251             :  *     }
     252             :  *
     253             :  * This visits all the contexts in pre-order, that is a node is visited
     254             :  * before its children.
     255             :  */
     256             : static MemoryContext
     257     1456644 : MemoryContextTraverseNext(MemoryContext curr, MemoryContext top)
     258             : {
     259             :     /* After processing a node, traverse to its first child if any */
     260     1456644 :     if (curr->firstchild != NULL)
     261           0 :         return curr->firstchild;
     262             : 
     263             :     /*
     264             :      * After processing a childless node, traverse to its next sibling if
     265             :      * there is one.  If there isn't, traverse back up to the parent (which
     266             :      * has already been visited, and now so have all its descendants).  We're
     267             :      * done if that is "top", otherwise traverse to its next sibling if any,
     268             :      * otherwise repeat moving up.
     269             :      */
     270     1456644 :     while (curr->nextchild == NULL)
     271             :     {
     272      559950 :         curr = curr->parent;
     273      559950 :         if (curr == top)
     274      559950 :             return NULL;
     275             :     }
     276      896694 :     return curr->nextchild;
     277             : }
     278             : 
     279             : /*
     280             :  * Support routines to trap use of invalid memory context method IDs
     281             :  * (from calling pfree or the like on a bogus pointer).  As a possible
     282             :  * aid in debugging, we report the header word along with the pointer
     283             :  * address (if we got here, there must be an accessible header word).
     284             :  */
     285             : static void
     286           0 : BogusFree(void *pointer)
     287             : {
     288           0 :     elog(ERROR, "pfree called with invalid pointer %p (header 0x%016llx)",
     289             :          pointer, (unsigned long long) GetMemoryChunkHeader(pointer));
     290             : }
     291             : 
     292             : static void *
     293           0 : BogusRealloc(void *pointer, Size size, int flags)
     294             : {
     295           0 :     elog(ERROR, "repalloc called with invalid pointer %p (header 0x%016llx)",
     296             :          pointer, (unsigned long long) GetMemoryChunkHeader(pointer));
     297             :     return NULL;                /* keep compiler quiet */
     298             : }
     299             : 
     300             : static MemoryContext
     301           0 : BogusGetChunkContext(void *pointer)
     302             : {
     303           0 :     elog(ERROR, "GetMemoryChunkContext called with invalid pointer %p (header 0x%016llx)",
     304             :          pointer, (unsigned long long) GetMemoryChunkHeader(pointer));
     305             :     return NULL;                /* keep compiler quiet */
     306             : }
     307             : 
     308             : static Size
     309           0 : BogusGetChunkSpace(void *pointer)
     310             : {
     311           0 :     elog(ERROR, "GetMemoryChunkSpace called with invalid pointer %p (header 0x%016llx)",
     312             :          pointer, (unsigned long long) GetMemoryChunkHeader(pointer));
     313             :     return 0;                   /* keep compiler quiet */
     314             : }
     315             : 
     316             : 
     317             : /*****************************************************************************
     318             :  *    EXPORTED ROUTINES                                                      *
     319             :  *****************************************************************************/
     320             : 
     321             : 
     322             : /*
     323             :  * MemoryContextInit
     324             :  *      Start up the memory-context subsystem.
     325             :  *
     326             :  * This must be called before creating contexts or allocating memory in
     327             :  * contexts.  TopMemoryContext and ErrorContext are initialized here;
     328             :  * other contexts must be created afterwards.
     329             :  *
     330             :  * In normal multi-backend operation, this is called once during
     331             :  * postmaster startup, and not at all by individual backend startup
     332             :  * (since the backends inherit an already-initialized context subsystem
     333             :  * by virtue of being forked off the postmaster).  But in an EXEC_BACKEND
     334             :  * build, each process must do this for itself.
     335             :  *
     336             :  * In a standalone backend this must be called during backend startup.
     337             :  */
     338             : void
     339        3078 : MemoryContextInit(void)
     340             : {
     341             :     Assert(TopMemoryContext == NULL);
     342             : 
     343             :     /*
     344             :      * First, initialize TopMemoryContext, which is the parent of all others.
     345             :      */
     346        3078 :     TopMemoryContext = AllocSetContextCreate((MemoryContext) NULL,
     347             :                                              "TopMemoryContext",
     348             :                                              ALLOCSET_DEFAULT_SIZES);
     349             : 
     350             :     /*
     351             :      * Not having any other place to point CurrentMemoryContext, make it point
     352             :      * to TopMemoryContext.  Caller should change this soon!
     353             :      */
     354        3078 :     CurrentMemoryContext = TopMemoryContext;
     355             : 
     356             :     /*
     357             :      * Initialize ErrorContext as an AllocSetContext with slow growth rate ---
     358             :      * we don't really expect much to be allocated in it. More to the point,
     359             :      * require it to contain at least 8K at all times. This is the only case
     360             :      * where retained memory in a context is *essential* --- we want to be
     361             :      * sure ErrorContext still has some memory even if we've run out
     362             :      * elsewhere! Also, allow allocations in ErrorContext within a critical
     363             :      * section. Otherwise a PANIC will cause an assertion failure in the error
     364             :      * reporting code, before printing out the real cause of the failure.
     365             :      *
     366             :      * This should be the last step in this function, as elog.c assumes memory
     367             :      * management works once ErrorContext is non-null.
     368             :      */
     369        3078 :     ErrorContext = AllocSetContextCreate(TopMemoryContext,
     370             :                                          "ErrorContext",
     371             :                                          8 * 1024,
     372             :                                          8 * 1024,
     373             :                                          8 * 1024);
     374        3078 :     MemoryContextAllowInCriticalSection(ErrorContext, true);
     375        3078 : }
     376             : 
     377             : /*
     378             :  * MemoryContextReset
     379             :  *      Release all space allocated within a context and delete all its
     380             :  *      descendant contexts (but not the named context itself).
     381             :  */
     382             : void
     383   278198784 : MemoryContextReset(MemoryContext context)
     384             : {
     385             :     Assert(MemoryContextIsValid(context));
     386             : 
     387             :     /* save a function call in common case where there are no children */
     388   278198784 :     if (context->firstchild != NULL)
     389      267780 :         MemoryContextDeleteChildren(context);
     390             : 
     391             :     /* save a function call if no pallocs since startup or last reset */
     392   278198784 :     if (!context->isReset)
     393    35127624 :         MemoryContextResetOnly(context);
     394   278198784 : }
     395             : 
     396             : /*
     397             :  * MemoryContextResetOnly
     398             :  *      Release all space allocated within a context.
     399             :  *      Nothing is done to the context's descendant contexts.
     400             :  */
     401             : void
     402    40739640 : MemoryContextResetOnly(MemoryContext context)
     403             : {
     404             :     Assert(MemoryContextIsValid(context));
     405             : 
     406             :     /* Nothing to do if no pallocs since startup or last reset */
     407    40739640 :     if (!context->isReset)
     408             :     {
     409    40738574 :         MemoryContextCallResetCallbacks(context);
     410             : 
     411             :         /*
     412             :          * If context->ident points into the context's memory, it will become
     413             :          * a dangling pointer.  We could prevent that by setting it to NULL
     414             :          * here, but that would break valid coding patterns that keep the
     415             :          * ident elsewhere, e.g. in a parent context.  So for now we assume
     416             :          * the programmer got it right.
     417             :          */
     418             : 
     419    40738574 :         context->methods->reset(context);
     420    40738574 :         context->isReset = true;
     421             :         VALGRIND_DESTROY_MEMPOOL(context);
     422             :         VALGRIND_CREATE_MEMPOOL(context, 0, false);
     423             :     }
     424    40739640 : }
     425             : 
     426             : /*
     427             :  * MemoryContextResetChildren
     428             :  *      Release all space allocated within a context's descendants,
     429             :  *      but don't delete the contexts themselves.  The named context
     430             :  *      itself is not touched.
     431             :  */
     432             : void
     433           0 : MemoryContextResetChildren(MemoryContext context)
     434             : {
     435             :     Assert(MemoryContextIsValid(context));
     436             : 
     437           0 :     for (MemoryContext curr = context->firstchild;
     438             :          curr != NULL;
     439           0 :          curr = MemoryContextTraverseNext(curr, context))
     440             :     {
     441           0 :         MemoryContextResetOnly(curr);
     442             :     }
     443           0 : }
     444             : 
     445             : /*
     446             :  * MemoryContextDelete
     447             :  *      Delete a context and its descendants, and release all space
     448             :  *      allocated therein.
     449             :  *
     450             :  * The type-specific delete routine removes all storage for the context,
     451             :  * but we have to deal with descendant nodes here.
     452             :  */
     453             : void
     454     8109812 : MemoryContextDelete(MemoryContext context)
     455             : {
     456             :     MemoryContext curr;
     457             : 
     458             :     Assert(MemoryContextIsValid(context));
     459             : 
     460             :     /*
     461             :      * Delete subcontexts from the bottom up.
     462             :      *
     463             :      * Note: Do not use recursion here.  A "stack depth limit exceeded" error
     464             :      * would be unpleasant if we're already in the process of cleaning up from
     465             :      * transaction abort.  We also cannot use MemoryContextTraverseNext() here
     466             :      * because we modify the tree as we go.
     467             :      */
     468     8109812 :     curr = context;
     469             :     for (;;)
     470      857742 :     {
     471             :         MemoryContext parent;
     472             : 
     473             :         /* Descend down until we find a leaf context with no children */
     474     9825296 :         while (curr->firstchild != NULL)
     475      857742 :             curr = curr->firstchild;
     476             : 
     477             :         /*
     478             :          * We're now at a leaf with no children. Free it and continue from the
     479             :          * parent.  Or if this was the original node, we're all done.
     480             :          */
     481     8967554 :         parent = curr->parent;
     482     8967554 :         MemoryContextDeleteOnly(curr);
     483             : 
     484     8967554 :         if (curr == context)
     485     8109812 :             break;
     486      857742 :         curr = parent;
     487             :     }
     488     8109812 : }
     489             : 
     490             : /*
     491             :  * Subroutine of MemoryContextDelete,
     492             :  * to delete a context that has no children.
     493             :  * We must also delink the context from its parent, if it has one.
     494             :  */
     495             : static void
     496     8967554 : MemoryContextDeleteOnly(MemoryContext context)
     497             : {
     498             :     Assert(MemoryContextIsValid(context));
     499             :     /* We had better not be deleting TopMemoryContext ... */
     500             :     Assert(context != TopMemoryContext);
     501             :     /* And not CurrentMemoryContext, either */
     502             :     Assert(context != CurrentMemoryContext);
     503             :     /* All the children should've been deleted already */
     504             :     Assert(context->firstchild == NULL);
     505             : 
     506             :     /*
     507             :      * It's not entirely clear whether 'tis better to do this before or after
     508             :      * delinking the context; but an error in a callback will likely result in
     509             :      * leaking the whole context (if it's not a root context) if we do it
     510             :      * after, so let's do it before.
     511             :      */
     512     8967554 :     MemoryContextCallResetCallbacks(context);
     513             : 
     514             :     /*
     515             :      * We delink the context from its parent before deleting it, so that if
     516             :      * there's an error we won't have deleted/busted contexts still attached
     517             :      * to the context tree.  Better a leak than a crash.
     518             :      */
     519     8967554 :     MemoryContextSetParent(context, NULL);
     520             : 
     521             :     /*
     522             :      * Also reset the context's ident pointer, in case it points into the
     523             :      * context.  This would only matter if someone tries to get stats on the
     524             :      * (already unlinked) context, which is unlikely, but let's be safe.
     525             :      */
     526     8967554 :     context->ident = NULL;
     527             : 
     528     8967554 :     context->methods->delete_context(context);
     529             : 
     530             :     VALGRIND_DESTROY_MEMPOOL(context);
     531     8967554 : }
     532             : 
     533             : /*
     534             :  * MemoryContextDeleteChildren
     535             :  *      Delete all the descendants of the named context and release all
     536             :  *      space allocated therein.  The named context itself is not touched.
     537             :  */
     538             : void
     539      648276 : MemoryContextDeleteChildren(MemoryContext context)
     540             : {
     541             :     Assert(MemoryContextIsValid(context));
     542             : 
     543             :     /*
     544             :      * MemoryContextDelete will delink the child from me, so just iterate as
     545             :      * long as there is a child.
     546             :      */
     547      969154 :     while (context->firstchild != NULL)
     548      320878 :         MemoryContextDelete(context->firstchild);
     549      648276 : }
     550             : 
     551             : /*
     552             :  * MemoryContextRegisterResetCallback
     553             :  *      Register a function to be called before next context reset/delete.
     554             :  *      Such callbacks will be called in reverse order of registration.
     555             :  *
     556             :  * The caller is responsible for allocating a MemoryContextCallback struct
     557             :  * to hold the info about this callback request, and for filling in the
     558             :  * "func" and "arg" fields in the struct to show what function to call with
     559             :  * what argument.  Typically the callback struct should be allocated within
     560             :  * the specified context, since that means it will automatically be freed
     561             :  * when no longer needed.
     562             :  *
     563             :  * There is no API for deregistering a callback once registered.  If you
     564             :  * want it to not do anything anymore, adjust the state pointed to by its
     565             :  * "arg" to indicate that.
     566             :  */
     567             : void
     568       42668 : MemoryContextRegisterResetCallback(MemoryContext context,
     569             :                                    MemoryContextCallback *cb)
     570             : {
     571             :     Assert(MemoryContextIsValid(context));
     572             : 
     573             :     /* Push onto head so this will be called before older registrants. */
     574       42668 :     cb->next = context->reset_cbs;
     575       42668 :     context->reset_cbs = cb;
     576             :     /* Mark the context as non-reset (it probably is already). */
     577       42668 :     context->isReset = false;
     578       42668 : }
     579             : 
     580             : /*
     581             :  * MemoryContextCallResetCallbacks
     582             :  *      Internal function to call all registered callbacks for context.
     583             :  */
     584             : static void
     585    49706128 : MemoryContextCallResetCallbacks(MemoryContext context)
     586             : {
     587             :     MemoryContextCallback *cb;
     588             : 
     589             :     /*
     590             :      * We pop each callback from the list before calling.  That way, if an
     591             :      * error occurs inside the callback, we won't try to call it a second time
     592             :      * in the likely event that we reset or delete the context later.
     593             :      */
     594    49748768 :     while ((cb = context->reset_cbs) != NULL)
     595             :     {
     596       42640 :         context->reset_cbs = cb->next;
     597       42640 :         cb->func(cb->arg);
     598             :     }
     599    49706128 : }
     600             : 
     601             : /*
     602             :  * MemoryContextSetIdentifier
     603             :  *      Set the identifier string for a memory context.
     604             :  *
     605             :  * An identifier can be provided to help distinguish among different contexts
     606             :  * of the same kind in memory context stats dumps.  The identifier string
     607             :  * must live at least as long as the context it is for; typically it is
     608             :  * allocated inside that context, so that it automatically goes away on
     609             :  * context deletion.  Pass id = NULL to forget any old identifier.
     610             :  */
     611             : void
     612     3473242 : MemoryContextSetIdentifier(MemoryContext context, const char *id)
     613             : {
     614             :     Assert(MemoryContextIsValid(context));
     615     3473242 :     context->ident = id;
     616     3473242 : }
     617             : 
     618             : /*
     619             :  * MemoryContextSetParent
     620             :  *      Change a context to belong to a new parent (or no parent).
     621             :  *
     622             :  * We provide this as an API function because it is sometimes useful to
     623             :  * change a context's lifespan after creation.  For example, a context
     624             :  * might be created underneath a transient context, filled with data,
     625             :  * and then reparented underneath CacheMemoryContext to make it long-lived.
     626             :  * In this way no special effort is needed to get rid of the context in case
     627             :  * a failure occurs before its contents are completely set up.
     628             :  *
     629             :  * Callers often assume that this function cannot fail, so don't put any
     630             :  * elog(ERROR) calls in it.
     631             :  *
     632             :  * A possible caller error is to reparent a context under itself, creating
     633             :  * a loop in the context graph.  We assert here that context != new_parent,
     634             :  * but checking for multi-level loops seems more trouble than it's worth.
     635             :  */
     636             : void
     637     9214226 : MemoryContextSetParent(MemoryContext context, MemoryContext new_parent)
     638             : {
     639             :     Assert(MemoryContextIsValid(context));
     640             :     Assert(context != new_parent);
     641             : 
     642             :     /* Fast path if it's got correct parent already */
     643     9214226 :     if (new_parent == context->parent)
     644        9388 :         return;
     645             : 
     646             :     /* Delink from existing parent, if any */
     647     9204838 :     if (context->parent)
     648             :     {
     649     9204838 :         MemoryContext parent = context->parent;
     650             : 
     651     9204838 :         if (context->prevchild != NULL)
     652      828204 :             context->prevchild->nextchild = context->nextchild;
     653             :         else
     654             :         {
     655             :             Assert(parent->firstchild == context);
     656     8376634 :             parent->firstchild = context->nextchild;
     657             :         }
     658             : 
     659     9204838 :         if (context->nextchild != NULL)
     660     3893496 :             context->nextchild->prevchild = context->prevchild;
     661             :     }
     662             : 
     663             :     /* And relink */
     664     9204838 :     if (new_parent)
     665             :     {
     666             :         Assert(MemoryContextIsValid(new_parent));
     667      237284 :         context->parent = new_parent;
     668      237284 :         context->prevchild = NULL;
     669      237284 :         context->nextchild = new_parent->firstchild;
     670      237284 :         if (new_parent->firstchild != NULL)
     671      214304 :             new_parent->firstchild->prevchild = context;
     672      237284 :         new_parent->firstchild = context;
     673             :     }
     674             :     else
     675             :     {
     676     8967554 :         context->parent = NULL;
     677     8967554 :         context->prevchild = NULL;
     678     8967554 :         context->nextchild = NULL;
     679             :     }
     680             : }
     681             : 
     682             : /*
     683             :  * MemoryContextAllowInCriticalSection
     684             :  *      Allow/disallow allocations in this memory context within a critical
     685             :  *      section.
     686             :  *
     687             :  * Normally, memory allocations are not allowed within a critical section,
     688             :  * because a failure would lead to PANIC.  There are a few exceptions to
     689             :  * that, like allocations related to debugging code that is not supposed to
     690             :  * be enabled in production.  This function can be used to exempt specific
     691             :  * memory contexts from the assertion in palloc().
     692             :  */
     693             : void
     694        4084 : MemoryContextAllowInCriticalSection(MemoryContext context, bool allow)
     695             : {
     696             :     Assert(MemoryContextIsValid(context));
     697             : 
     698        4084 :     context->allowInCritSection = allow;
     699        4084 : }
     700             : 
     701             : /*
     702             :  * GetMemoryChunkContext
     703             :  *      Given a currently-allocated chunk, determine the MemoryContext that
     704             :  *      the chunk belongs to.
     705             :  */
     706             : MemoryContext
     707     2872078 : GetMemoryChunkContext(void *pointer)
     708             : {
     709     2872078 :     return MCXT_METHOD(pointer, get_chunk_context) (pointer);
     710             : }
     711             : 
     712             : /*
     713             :  * GetMemoryChunkSpace
     714             :  *      Given a currently-allocated chunk, determine the total space
     715             :  *      it occupies (including all memory-allocation overhead).
     716             :  *
     717             :  * This is useful for measuring the total space occupied by a set of
     718             :  * allocated chunks.
     719             :  */
     720             : Size
     721    45773424 : GetMemoryChunkSpace(void *pointer)
     722             : {
     723    45773424 :     return MCXT_METHOD(pointer, get_chunk_space) (pointer);
     724             : }
     725             : 
     726             : /*
     727             :  * MemoryContextGetParent
     728             :  *      Get the parent context (if any) of the specified context
     729             :  */
     730             : MemoryContext
     731       16970 : MemoryContextGetParent(MemoryContext context)
     732             : {
     733             :     Assert(MemoryContextIsValid(context));
     734             : 
     735       16970 :     return context->parent;
     736             : }
     737             : 
     738             : /*
     739             :  * MemoryContextIsEmpty
     740             :  *      Is a memory context empty of any allocated space?
     741             :  */
     742             : bool
     743        8880 : MemoryContextIsEmpty(MemoryContext context)
     744             : {
     745             :     Assert(MemoryContextIsValid(context));
     746             : 
     747             :     /*
     748             :      * For now, we consider a memory context nonempty if it has any children;
     749             :      * perhaps this should be changed later.
     750             :      */
     751        8880 :     if (context->firstchild != NULL)
     752           2 :         return false;
     753             :     /* Otherwise use the type-specific inquiry */
     754        8878 :     return context->methods->is_empty(context);
     755             : }
     756             : 
     757             : /*
     758             :  * Find the memory allocated to blocks for this memory context. If recurse is
     759             :  * true, also include children.
     760             :  */
     761             : Size
     762     1002524 : MemoryContextMemAllocated(MemoryContext context, bool recurse)
     763             : {
     764     1002524 :     Size        total = context->mem_allocated;
     765             : 
     766             :     Assert(MemoryContextIsValid(context));
     767             : 
     768     1002524 :     if (recurse)
     769             :     {
     770     2459168 :         for (MemoryContext curr = context->firstchild;
     771             :              curr != NULL;
     772     1456644 :              curr = MemoryContextTraverseNext(curr, context))
     773             :         {
     774     1456644 :             total += curr->mem_allocated;
     775             :         }
     776             :     }
     777             : 
     778     1002524 :     return total;
     779             : }
     780             : 
     781             : /*
     782             :  * Return the memory consumption statistics about the given context and its
     783             :  * children.
     784             :  */
     785             : void
     786          30 : MemoryContextMemConsumed(MemoryContext context,
     787             :                          MemoryContextCounters *consumed)
     788             : {
     789             :     Assert(MemoryContextIsValid(context));
     790             : 
     791          30 :     memset(consumed, 0, sizeof(*consumed));
     792             : 
     793             :     /* Examine the context itself */
     794          30 :     context->methods->stats(context, NULL, NULL, consumed, false);
     795             : 
     796             :     /* Examine children, using iteration not recursion */
     797          30 :     for (MemoryContext curr = context->firstchild;
     798             :          curr != NULL;
     799           0 :          curr = MemoryContextTraverseNext(curr, context))
     800             :     {
     801           0 :         curr->methods->stats(curr, NULL, NULL, consumed, false);
     802             :     }
     803          30 : }
     804             : 
     805             : /*
     806             :  * MemoryContextStats
     807             :  *      Print statistics about the named context and all its descendants.
     808             :  *
     809             :  * This is just a debugging utility, so it's not very fancy.  However, we do
     810             :  * make some effort to summarize when the output would otherwise be very long.
     811             :  * The statistics are sent to stderr.
     812             :  */
     813             : void
     814           0 : MemoryContextStats(MemoryContext context)
     815             : {
     816             :     /* Hard-wired limits are usually good enough */
     817           0 :     MemoryContextStatsDetail(context, 100, 100, true);
     818           0 : }
     819             : 
     820             : /*
     821             :  * MemoryContextStatsDetail
     822             :  *
     823             :  * Entry point for use if you want to vary the number of child contexts shown.
     824             :  *
     825             :  * If print_to_stderr is true, print statistics about the memory contexts
     826             :  * with fprintf(stderr), otherwise use ereport().
     827             :  */
     828             : void
     829          18 : MemoryContextStatsDetail(MemoryContext context,
     830             :                          int max_level, int max_children,
     831             :                          bool print_to_stderr)
     832             : {
     833             :     MemoryContextCounters grand_totals;
     834             : 
     835          18 :     memset(&grand_totals, 0, sizeof(grand_totals));
     836             : 
     837          18 :     MemoryContextStatsInternal(context, 0, max_level, max_children,
     838             :                                &grand_totals, print_to_stderr);
     839             : 
     840          18 :     if (print_to_stderr)
     841           0 :         fprintf(stderr,
     842             :                 "Grand total: %zu bytes in %zu blocks; %zu free (%zu chunks); %zu used\n",
     843             :                 grand_totals.totalspace, grand_totals.nblocks,
     844             :                 grand_totals.freespace, grand_totals.freechunks,
     845           0 :                 grand_totals.totalspace - grand_totals.freespace);
     846             :     else
     847             :     {
     848             :         /*
     849             :          * Use LOG_SERVER_ONLY to prevent the memory contexts from being sent
     850             :          * to the connected client.
     851             :          *
     852             :          * We don't buffer the information about all memory contexts in a
     853             :          * backend into StringInfo and log it as one message.  That would
     854             :          * require the buffer to be enlarged, risking an OOM as there could be
     855             :          * a large number of memory contexts in a backend.  Instead, we log
     856             :          * one message per memory context.
     857             :          */
     858          18 :         ereport(LOG_SERVER_ONLY,
     859             :                 (errhidestmt(true),
     860             :                  errhidecontext(true),
     861             :                  errmsg_internal("Grand total: %zu bytes in %zu blocks; %zu free (%zu chunks); %zu used",
     862             :                                  grand_totals.totalspace, grand_totals.nblocks,
     863             :                                  grand_totals.freespace, grand_totals.freechunks,
     864             :                                  grand_totals.totalspace - grand_totals.freespace)));
     865             :     }
     866          18 : }
     867             : 
     868             : /*
     869             :  * MemoryContextStatsInternal
     870             :  *      One recursion level for MemoryContextStats
     871             :  *
     872             :  * Print stats for this context if possible, but in any case accumulate counts
     873             :  * into *totals (if not NULL).
     874             :  */
     875             : static void
     876        1548 : MemoryContextStatsInternal(MemoryContext context, int level,
     877             :                            int max_level, int max_children,
     878             :                            MemoryContextCounters *totals,
     879             :                            bool print_to_stderr)
     880             : {
     881             :     MemoryContext child;
     882             :     int         ichild;
     883             : 
     884             :     Assert(MemoryContextIsValid(context));
     885             : 
     886             :     /* Examine the context itself */
     887        1548 :     context->methods->stats(context,
     888             :                             MemoryContextStatsPrint,
     889             :                             (void *) &level,
     890             :                             totals, print_to_stderr);
     891             : 
     892             :     /*
     893             :      * Examine children.
     894             :      *
     895             :      * If we are past the recursion depth limit or already running low on
     896             :      * stack, do not print them explicitly but just summarize them. Similarly,
     897             :      * if there are more than max_children of them, we do not print the rest
     898             :      * explicitly, but just summarize them.
     899             :      */
     900        1548 :     child = context->firstchild;
     901        1548 :     ichild = 0;
     902        1548 :     if (level < max_level && !stack_is_too_deep())
     903             :     {
     904        3078 :         for (; child != NULL && ichild < max_children;
     905        1530 :              child = child->nextchild, ichild++)
     906             :         {
     907        1530 :             MemoryContextStatsInternal(child, level + 1,
     908             :                                        max_level, max_children,
     909             :                                        totals,
     910             :                                        print_to_stderr);
     911             :         }
     912             :     }
     913             : 
     914        1548 :     if (child != NULL)
     915             :     {
     916             :         /* Summarize the rest of the children, avoiding recursion. */
     917             :         MemoryContextCounters local_totals;
     918             : 
     919           0 :         memset(&local_totals, 0, sizeof(local_totals));
     920             : 
     921           0 :         ichild = 0;
     922           0 :         while (child != NULL)
     923             :         {
     924           0 :             child->methods->stats(child, NULL, NULL, &local_totals, false);
     925           0 :             ichild++;
     926           0 :             child = MemoryContextTraverseNext(child, context);
     927             :         }
     928             : 
     929           0 :         if (print_to_stderr)
     930             :         {
     931           0 :             for (int i = 0; i <= level; i++)
     932           0 :                 fprintf(stderr, "  ");
     933           0 :             fprintf(stderr,
     934             :                     "%d more child contexts containing %zu total in %zu blocks; %zu free (%zu chunks); %zu used\n",
     935             :                     ichild,
     936             :                     local_totals.totalspace,
     937             :                     local_totals.nblocks,
     938             :                     local_totals.freespace,
     939             :                     local_totals.freechunks,
     940           0 :                     local_totals.totalspace - local_totals.freespace);
     941             :         }
     942             :         else
     943           0 :             ereport(LOG_SERVER_ONLY,
     944             :                     (errhidestmt(true),
     945             :                      errhidecontext(true),
     946             :                      errmsg_internal("level: %d; %d more child contexts containing %zu total in %zu blocks; %zu free (%zu chunks); %zu used",
     947             :                                      level,
     948             :                                      ichild,
     949             :                                      local_totals.totalspace,
     950             :                                      local_totals.nblocks,
     951             :                                      local_totals.freespace,
     952             :                                      local_totals.freechunks,
     953             :                                      local_totals.totalspace - local_totals.freespace)));
     954             : 
     955           0 :         if (totals)
     956             :         {
     957           0 :             totals->nblocks += local_totals.nblocks;
     958           0 :             totals->freechunks += local_totals.freechunks;
     959           0 :             totals->totalspace += local_totals.totalspace;
     960           0 :             totals->freespace += local_totals.freespace;
     961             :         }
     962             :     }
     963        1548 : }
     964             : 
     965             : /*
     966             :  * MemoryContextStatsPrint
     967             :  *      Print callback used by MemoryContextStatsInternal
     968             :  *
     969             :  * For now, the passthru pointer just points to "int level"; later we might
     970             :  * make that more complicated.
     971             :  */
     972             : static void
     973        1548 : MemoryContextStatsPrint(MemoryContext context, void *passthru,
     974             :                         const char *stats_string,
     975             :                         bool print_to_stderr)
     976             : {
     977        1548 :     int         level = *(int *) passthru;
     978        1548 :     const char *name = context->name;
     979        1548 :     const char *ident = context->ident;
     980             :     char        truncated_ident[110];
     981             :     int         i;
     982             : 
     983             :     /*
     984             :      * It seems preferable to label dynahash contexts with just the hash table
     985             :      * name.  Those are already unique enough, so the "dynahash" part isn't
     986             :      * very helpful, and this way is more consistent with pre-v11 practice.
     987             :      */
     988        1548 :     if (ident && strcmp(name, "dynahash") == 0)
     989             :     {
     990         180 :         name = ident;
     991         180 :         ident = NULL;
     992             :     }
     993             : 
     994        1548 :     truncated_ident[0] = '\0';
     995             : 
     996        1548 :     if (ident)
     997             :     {
     998             :         /*
     999             :          * Some contexts may have very long identifiers (e.g., SQL queries).
    1000             :          * Arbitrarily truncate at 100 bytes, but be careful not to break
    1001             :          * multibyte characters.  Also, replace ASCII control characters, such
    1002             :          * as newlines, with spaces.
    1003             :          */
    1004        1098 :         int         idlen = strlen(ident);
    1005        1098 :         bool        truncated = false;
    1006             : 
    1007        1098 :         strcpy(truncated_ident, ": ");
    1008        1098 :         i = strlen(truncated_ident);
    1009             : 
    1010        1098 :         if (idlen > 100)
    1011             :         {
    1012           0 :             idlen = pg_mbcliplen(ident, idlen, 100);
    1013           0 :             truncated = true;
    1014             :         }
    1015             : 
    1016       30342 :         while (idlen-- > 0)
    1017             :         {
    1018       29244 :             unsigned char c = *ident++;
    1019             : 
    1020       29244 :             if (c < ' ')
    1021           0 :                 c = ' ';
    1022       29244 :             truncated_ident[i++] = c;
    1023             :         }
    1024        1098 :         truncated_ident[i] = '\0';
    1025             : 
    1026        1098 :         if (truncated)
    1027           0 :             strcat(truncated_ident, "...");
    1028             :     }
    1029             : 
    1030        1548 :     if (print_to_stderr)
    1031             :     {
    1032           0 :         for (i = 0; i < level; i++)
    1033           0 :             fprintf(stderr, "  ");
    1034           0 :         fprintf(stderr, "%s: %s%s\n", name, stats_string, truncated_ident);
    1035             :     }
    1036             :     else
    1037        1548 :         ereport(LOG_SERVER_ONLY,
    1038             :                 (errhidestmt(true),
    1039             :                  errhidecontext(true),
    1040             :                  errmsg_internal("level: %d; %s: %s%s",
    1041             :                                  level, name, stats_string, truncated_ident)));
    1042        1548 : }
    1043             : 
    1044             : /*
    1045             :  * MemoryContextCheck
    1046             :  *      Check all chunks in the named context and its children.
    1047             :  *
    1048             :  * This is just a debugging utility, so it's not fancy.
    1049             :  */
    1050             : #ifdef MEMORY_CONTEXT_CHECKING
    1051             : void
    1052             : MemoryContextCheck(MemoryContext context)
    1053             : {
    1054             :     Assert(MemoryContextIsValid(context));
    1055             :     context->methods->check(context);
    1056             : 
    1057             :     for (MemoryContext curr = context->firstchild;
    1058             :          curr != NULL;
    1059             :          curr = MemoryContextTraverseNext(curr, context))
    1060             :     {
    1061             :         Assert(MemoryContextIsValid(curr));
    1062             :         curr->methods->check(curr);
    1063             :     }
    1064             : }
    1065             : #endif
    1066             : 
    1067             : /*
    1068             :  * MemoryContextCreate
    1069             :  *      Context-type-independent part of context creation.
    1070             :  *
    1071             :  * This is only intended to be called by context-type-specific
    1072             :  * context creation routines, not by the unwashed masses.
    1073             :  *
    1074             :  * The memory context creation procedure goes like this:
    1075             :  *  1.  Context-type-specific routine makes some initial space allocation,
    1076             :  *      including enough space for the context header.  If it fails,
    1077             :  *      it can ereport() with no damage done.
    1078             :  *  2.  Context-type-specific routine sets up all type-specific fields of
    1079             :  *      the header (those beyond MemoryContextData proper), as well as any
    1080             :  *      other management fields it needs to have a fully valid context.
    1081             :  *      Usually, failure in this step is impossible, but if it's possible
    1082             :  *      the initial space allocation should be freed before ereport'ing.
    1083             :  *  3.  Context-type-specific routine calls MemoryContextCreate() to fill in
    1084             :  *      the generic header fields and link the context into the context tree.
    1085             :  *  4.  We return to the context-type-specific routine, which finishes
    1086             :  *      up type-specific initialization.  This routine can now do things
    1087             :  *      that might fail (like allocate more memory), so long as it's
    1088             :  *      sure the node is left in a state that delete will handle.
    1089             :  *
    1090             :  * node: the as-yet-uninitialized common part of the context header node.
    1091             :  * tag: NodeTag code identifying the memory context type.
    1092             :  * method_id: MemoryContextMethodID of the context-type being created.
    1093             :  * parent: parent context, or NULL if this will be a top-level context.
    1094             :  * name: name of context (must be statically allocated).
    1095             :  *
    1096             :  * Context routines generally assume that MemoryContextCreate can't fail,
    1097             :  * so this can contain Assert but not elog/ereport.
    1098             :  */
    1099             : void
    1100    11427246 : MemoryContextCreate(MemoryContext node,
    1101             :                     NodeTag tag,
    1102             :                     MemoryContextMethodID method_id,
    1103             :                     MemoryContext parent,
    1104             :                     const char *name)
    1105             : {
    1106             :     /* Creating new memory contexts is not allowed in a critical section */
    1107             :     Assert(CritSectionCount == 0);
    1108             : 
    1109             :     /* Initialize all standard fields of memory context header */
    1110    11427246 :     node->type = tag;
    1111    11427246 :     node->isReset = true;
    1112    11427246 :     node->methods = &mcxt_methods[method_id];
    1113    11427246 :     node->parent = parent;
    1114    11427246 :     node->firstchild = NULL;
    1115    11427246 :     node->mem_allocated = 0;
    1116    11427246 :     node->prevchild = NULL;
    1117    11427246 :     node->name = name;
    1118    11427246 :     node->ident = NULL;
    1119    11427246 :     node->reset_cbs = NULL;
    1120             : 
    1121             :     /* OK to link node into context tree */
    1122    11427246 :     if (parent)
    1123             :     {
    1124    11424088 :         node->nextchild = parent->firstchild;
    1125    11424088 :         if (parent->firstchild != NULL)
    1126     6217844 :             parent->firstchild->prevchild = node;
    1127    11424088 :         parent->firstchild = node;
    1128             :         /* inherit allowInCritSection flag from parent */
    1129    11424088 :         node->allowInCritSection = parent->allowInCritSection;
    1130             :     }
    1131             :     else
    1132             :     {
    1133        3158 :         node->nextchild = NULL;
    1134        3158 :         node->allowInCritSection = false;
    1135             :     }
    1136             : 
    1137             :     VALGRIND_CREATE_MEMPOOL(node, 0, false);
    1138    11427246 : }
    1139             : 
    1140             : /*
    1141             :  * MemoryContextAllocationFailure
    1142             :  *      For use by MemoryContextMethods implementations to handle when malloc
    1143             :  *      returns NULL.  The behavior is specific to whether MCXT_ALLOC_NO_OOM
    1144             :  *      is in 'flags'.
    1145             :  */
    1146             : void *
    1147           0 : MemoryContextAllocationFailure(MemoryContext context, Size size, int flags)
    1148             : {
    1149           0 :     if ((flags & MCXT_ALLOC_NO_OOM) == 0)
    1150             :     {
    1151           0 :         MemoryContextStats(TopMemoryContext);
    1152           0 :         ereport(ERROR,
    1153             :                 (errcode(ERRCODE_OUT_OF_MEMORY),
    1154             :                  errmsg("out of memory"),
    1155             :                  errdetail("Failed on request of size %zu in memory context \"%s\".",
    1156             :                            size, context->name)));
    1157             :     }
    1158           0 :     return NULL;
    1159             : }
    1160             : 
    1161             : /*
    1162             :  * MemoryContextSizeFailure
    1163             :  *      For use by MemoryContextMethods implementations to handle invalid
    1164             :  *      memory allocation request sizes.
    1165             :  */
    1166             : void
    1167           0 : MemoryContextSizeFailure(MemoryContext context, Size size, int flags)
    1168             : {
    1169           0 :     elog(ERROR, "invalid memory alloc request size %zu", size);
    1170             : }
    1171             : 
    1172             : /*
    1173             :  * MemoryContextAlloc
    1174             :  *      Allocate space within the specified context.
    1175             :  *
    1176             :  * This could be turned into a macro, but we'd have to import
    1177             :  * nodes/memnodes.h into postgres.h which seems a bad idea.
    1178             :  */
    1179             : void *
    1180   142343670 : MemoryContextAlloc(MemoryContext context, Size size)
    1181             : {
    1182             :     void       *ret;
    1183             : 
    1184             :     Assert(MemoryContextIsValid(context));
    1185             :     AssertNotInCriticalSection(context);
    1186             : 
    1187   142343670 :     context->isReset = false;
    1188             : 
    1189             :     /*
    1190             :      * For efficiency reasons, we purposefully offload the handling of
    1191             :      * allocation failures to the MemoryContextMethods implementation as this
    1192             :      * allows these checks to be performed only when an actual malloc needs to
    1193             :      * be done to request more memory from the OS.  Additionally, not having
    1194             :      * to execute any instructions after this call allows the compiler to use
    1195             :      * the sibling call optimization.  If you're considering adding code after
    1196             :      * this call, consider making it the responsibility of the 'alloc'
    1197             :      * function instead.
    1198             :      */
    1199   142343670 :     ret = context->methods->alloc(context, size, 0);
    1200             : 
    1201             :     VALGRIND_MEMPOOL_ALLOC(context, ret, size);
    1202             : 
    1203   142343670 :     return ret;
    1204             : }
    1205             : 
    1206             : /*
    1207             :  * MemoryContextAllocZero
    1208             :  *      Like MemoryContextAlloc, but clears allocated memory
    1209             :  *
    1210             :  *  We could just call MemoryContextAlloc then clear the memory, but this
    1211             :  *  is a very common combination, so we provide the combined operation.
    1212             :  */
    1213             : void *
    1214    36333330 : MemoryContextAllocZero(MemoryContext context, Size size)
    1215             : {
    1216             :     void       *ret;
    1217             : 
    1218             :     Assert(MemoryContextIsValid(context));
    1219             :     AssertNotInCriticalSection(context);
    1220             : 
    1221    36333330 :     context->isReset = false;
    1222             : 
    1223    36333330 :     ret = context->methods->alloc(context, size, 0);
    1224             : 
    1225             :     VALGRIND_MEMPOOL_ALLOC(context, ret, size);
    1226             : 
    1227   398943446 :     MemSetAligned(ret, 0, size);
    1228             : 
    1229    36333330 :     return ret;
    1230             : }
    1231             : 
    1232             : /*
    1233             :  * MemoryContextAllocExtended
    1234             :  *      Allocate space within the specified context using the given flags.
    1235             :  */
    1236             : void *
    1237     5683072 : MemoryContextAllocExtended(MemoryContext context, Size size, int flags)
    1238             : {
    1239             :     void       *ret;
    1240             : 
    1241             :     Assert(MemoryContextIsValid(context));
    1242             :     AssertNotInCriticalSection(context);
    1243             : 
    1244     5683072 :     if (!((flags & MCXT_ALLOC_HUGE) != 0 ? AllocHugeSizeIsValid(size) :
    1245             :           AllocSizeIsValid(size)))
    1246           0 :         elog(ERROR, "invalid memory alloc request size %zu", size);
    1247             : 
    1248     5683072 :     context->isReset = false;
    1249             : 
    1250     5683072 :     ret = context->methods->alloc(context, size, flags);
    1251     5683072 :     if (unlikely(ret == NULL))
    1252           0 :         return NULL;
    1253             : 
    1254             :     VALGRIND_MEMPOOL_ALLOC(context, ret, size);
    1255             : 
    1256     5683072 :     if ((flags & MCXT_ALLOC_ZERO) != 0)
    1257   157040722 :         MemSetAligned(ret, 0, size);
    1258             : 
    1259     5683072 :     return ret;
    1260             : }
    1261             : 
    1262             : /*
    1263             :  * HandleLogMemoryContextInterrupt
    1264             :  *      Handle receipt of an interrupt indicating logging of memory
    1265             :  *      contexts.
    1266             :  *
    1267             :  * All the actual work is deferred to ProcessLogMemoryContextInterrupt(),
    1268             :  * because we cannot safely emit a log message inside the signal handler.
    1269             :  */
    1270             : void
    1271          18 : HandleLogMemoryContextInterrupt(void)
    1272             : {
    1273          18 :     InterruptPending = true;
    1274          18 :     LogMemoryContextPending = true;
    1275             :     /* latch will be set by procsignal_sigusr1_handler */
    1276          18 : }
    1277             : 
    1278             : /*
    1279             :  * ProcessLogMemoryContextInterrupt
    1280             :  *      Perform logging of memory contexts of this backend process.
    1281             :  *
    1282             :  * Any backend that participates in ProcSignal signaling must arrange
    1283             :  * to call this function if we see LogMemoryContextPending set.
    1284             :  * It is called from CHECK_FOR_INTERRUPTS(), which is enough because
    1285             :  * the target process for logging of memory contexts is a backend.
    1286             :  */
    1287             : void
    1288          18 : ProcessLogMemoryContextInterrupt(void)
    1289             : {
    1290          18 :     LogMemoryContextPending = false;
    1291             : 
    1292             :     /*
    1293             :      * Use LOG_SERVER_ONLY to prevent this message from being sent to the
    1294             :      * connected client.
    1295             :      */
    1296          18 :     ereport(LOG_SERVER_ONLY,
    1297             :             (errhidestmt(true),
    1298             :              errhidecontext(true),
    1299             :              errmsg("logging memory contexts of PID %d", MyProcPid)));
    1300             : 
    1301             :     /*
    1302             :      * When a backend process is consuming huge memory, logging all its memory
    1303             :      * contexts might overrun available disk space. To prevent this, we limit
    1304             :      * the depth of the hierarchy, as well as the number of child contexts to
    1305             :      * log per parent to 100.
    1306             :      *
    1307             :      * As with MemoryContextStats(), we suppose that practical cases where the
    1308             :      * dump gets long will typically be huge numbers of siblings under the
    1309             :      * same parent context; while the additional debugging value from seeing
    1310             :      * details about individual siblings beyond 100 will not be large.
    1311             :      */
    1312          18 :     MemoryContextStatsDetail(TopMemoryContext, 100, 100, false);
    1313          18 : }
    1314             : 
    1315             : void *
    1316   504789670 : palloc(Size size)
    1317             : {
    1318             :     /* duplicates MemoryContextAlloc to avoid increased overhead */
    1319             :     void       *ret;
    1320   504789670 :     MemoryContext context = CurrentMemoryContext;
    1321             : 
    1322             :     Assert(MemoryContextIsValid(context));
    1323             :     AssertNotInCriticalSection(context);
    1324             : 
    1325   504789670 :     context->isReset = false;
    1326             : 
    1327             :     /*
    1328             :      * For efficiency reasons, we purposefully offload the handling of
    1329             :      * allocation failures to the MemoryContextMethods implementation as this
    1330             :      * allows these checks to be performed only when an actual malloc needs to
    1331             :      * be done to request more memory from the OS.  Additionally, not having
    1332             :      * to execute any instructions after this call allows the compiler to use
    1333             :      * the sibling call optimization.  If you're considering adding code after
    1334             :      * this call, consider making it the responsibility of the 'alloc'
    1335             :      * function instead.
    1336             :      */
    1337   504789670 :     ret = context->methods->alloc(context, size, 0);
    1338             :     /* We expect OOM to be handled by the alloc function */
    1339             :     Assert(ret != NULL);
    1340             :     VALGRIND_MEMPOOL_ALLOC(context, ret, size);
    1341             : 
    1342   504789670 :     return ret;
    1343             : }
    1344             : 
    1345             : void *
    1346   399940684 : palloc0(Size size)
    1347             : {
    1348             :     /* duplicates MemoryContextAllocZero to avoid increased overhead */
    1349             :     void       *ret;
    1350   399940684 :     MemoryContext context = CurrentMemoryContext;
    1351             : 
    1352             :     Assert(MemoryContextIsValid(context));
    1353             :     AssertNotInCriticalSection(context);
    1354             : 
    1355   399940684 :     context->isReset = false;
    1356             : 
    1357   399940684 :     ret = context->methods->alloc(context, size, 0);
    1358             : 
    1359             :     VALGRIND_MEMPOOL_ALLOC(context, ret, size);
    1360             : 
    1361  3479557568 :     MemSetAligned(ret, 0, size);
    1362             : 
    1363   399940684 :     return ret;
    1364             : }
    1365             : 
    1366             : void *
    1367     1675690 : palloc_extended(Size size, int flags)
    1368             : {
    1369             :     /* duplicates MemoryContextAllocExtended to avoid increased overhead */
    1370             :     void       *ret;
    1371     1675690 :     MemoryContext context = CurrentMemoryContext;
    1372             : 
    1373             :     Assert(MemoryContextIsValid(context));
    1374             :     AssertNotInCriticalSection(context);
    1375             : 
    1376     1675690 :     context->isReset = false;
    1377             : 
    1378     1675690 :     ret = context->methods->alloc(context, size, flags);
    1379     1675690 :     if (unlikely(ret == NULL))
    1380             :     {
    1381           0 :         return NULL;
    1382             :     }
    1383             : 
    1384             :     VALGRIND_MEMPOOL_ALLOC(context, ret, size);
    1385             : 
    1386     1675690 :     if ((flags & MCXT_ALLOC_ZERO) != 0)
    1387        4774 :         MemSetAligned(ret, 0, size);
    1388             : 
    1389     1675690 :     return ret;
    1390             : }
    1391             : 
    1392             : /*
    1393             :  * MemoryContextAllocAligned
    1394             :  *      Allocate 'size' bytes of memory in 'context' aligned to 'alignto'
    1395             :  *      bytes.
    1396             :  *
    1397             :  * Currently, we align addresses by requesting additional bytes from the
    1398             :  * MemoryContext's standard allocator function and then aligning the returned
    1399             :  * address by the required alignment.  This means that the given MemoryContext
    1400             :  * must support providing us with a chunk of memory that's larger than 'size'.
    1401             :  * For allocators such as Slab, that's not going to work, as slab only allows
    1402             :  * chunks of the size that's specified when the context is created.
    1403             :  *
    1404             :  * 'alignto' must be a power of 2.
    1405             :  * 'flags' may be 0 or set the same as MemoryContextAllocExtended().
    1406             :  */
    1407             : void *
    1408     2467094 : MemoryContextAllocAligned(MemoryContext context,
    1409             :                           Size size, Size alignto, int flags)
    1410             : {
    1411             :     MemoryChunk *alignedchunk;
    1412             :     Size        alloc_size;
    1413             :     void       *unaligned;
    1414             :     void       *aligned;
    1415             : 
    1416             :     /* wouldn't make much sense to waste that much space */
    1417             :     Assert(alignto < (128 * 1024 * 1024));
    1418             : 
    1419             :     /* ensure alignto is a power of 2 */
    1420             :     Assert((alignto & (alignto - 1)) == 0);
    1421             : 
    1422             :     /*
    1423             :      * If the alignment requirements are less than what we already guarantee
    1424             :      * then just use the standard allocation function.
    1425             :      */
    1426     2467094 :     if (unlikely(alignto <= MAXIMUM_ALIGNOF))
    1427           0 :         return MemoryContextAllocExtended(context, size, flags);
    1428             : 
    1429             :     /*
    1430             :      * We implement aligned pointers by simply allocating enough memory for
    1431             :      * the requested size plus the alignment and an additional "redirection"
    1432             :      * MemoryChunk.  This additional MemoryChunk is required for operations
    1433             :      * such as pfree when used on the pointer returned by this function.  We
    1434             :      * use this redirection MemoryChunk in order to find the pointer to the
    1435             :      * memory that was returned by the MemoryContextAllocExtended call below.
    1436             :      * We do that by "borrowing" the block offset field and instead of using
    1437             :      * that to find the offset into the owning block, we use it to find the
    1438             :      * original allocated address.
    1439             :      *
    1440             :      * Here we must allocate enough extra memory so that we can still align
    1441             :      * the pointer returned by MemoryContextAllocExtended and also have enough
    1442             :      * space for the redirection MemoryChunk.  Since allocations will already
    1443             :      * be at least aligned by MAXIMUM_ALIGNOF, we can subtract that amount
    1444             :      * from the allocation size to save a little memory.
    1445             :      */
    1446     2467094 :     alloc_size = size + PallocAlignedExtraBytes(alignto);
    1447             : 
    1448             : #ifdef MEMORY_CONTEXT_CHECKING
    1449             :     /* ensure there's space for a sentinel byte */
    1450             :     alloc_size += 1;
    1451             : #endif
    1452             : 
    1453             :     /* perform the actual allocation */
    1454     2467094 :     unaligned = MemoryContextAllocExtended(context, alloc_size, flags);
    1455             : 
    1456             :     /* set the aligned pointer */
    1457     2467094 :     aligned = (void *) TYPEALIGN(alignto, (char *) unaligned +
    1458             :                                  sizeof(MemoryChunk));
    1459             : 
    1460     2467094 :     alignedchunk = PointerGetMemoryChunk(aligned);
    1461             : 
    1462             :     /*
    1463             :      * We set the redirect MemoryChunk so that the block offset calculation is
    1464             :      * used to point back to the 'unaligned' allocated chunk.  This allows us
    1465             :      * to use MemoryChunkGetBlock() to find the unaligned chunk when we need
    1466             :      * to perform operations such as pfree() and repalloc().
    1467             :      *
    1468             :      * We store 'alignto' in the MemoryChunk's 'value' so that we know what
    1469             :      * the alignment was set to should we ever be asked to realloc this
    1470             :      * pointer.
    1471             :      */
    1472     2467094 :     MemoryChunkSetHdrMask(alignedchunk, unaligned, alignto,
    1473             :                           MCTX_ALIGNED_REDIRECT_ID);
    1474             : 
    1475             :     /* double check we produced a correctly aligned pointer */
    1476             :     Assert((void *) TYPEALIGN(alignto, aligned) == aligned);
    1477             : 
    1478             : #ifdef MEMORY_CONTEXT_CHECKING
    1479             :     alignedchunk->requested_size = size;
    1480             :     /* set mark to catch clobber of "unused" space */
    1481             :     set_sentinel(aligned, size);
    1482             : #endif
    1483             : 
    1484             :     /* Mark the bytes before the redirection header as noaccess */
    1485             :     VALGRIND_MAKE_MEM_NOACCESS(unaligned,
    1486             :                                (char *) alignedchunk - (char *) unaligned);
    1487             : 
    1488             :     /* Disallow access to the redirection chunk header. */
    1489             :     VALGRIND_MAKE_MEM_NOACCESS(alignedchunk, sizeof(MemoryChunk));
    1490             : 
    1491     2467094 :     return aligned;
    1492             : }
    1493             : 
    1494             : /*
    1495             :  * palloc_aligned
    1496             :  *      Allocate 'size' bytes returning a pointer that's aligned to the
    1497             :  *      'alignto' boundary.
    1498             :  *
    1499             :  * Currently, we align addresses by requesting additional bytes from the
    1500             :  * MemoryContext's standard allocator function and then aligning the returned
    1501             :  * address by the required alignment.  This means that the given MemoryContext
    1502             :  * must support providing us with a chunk of memory that's larger than 'size'.
    1503             :  * For allocators such as Slab, that's not going to work, as slab only allows
    1504             :  * chunks of the size that's specified when the context is created.
    1505             :  *
    1506             :  * 'alignto' must be a power of 2.
    1507             :  * 'flags' may be 0 or set the same as MemoryContextAllocExtended().
    1508             :  */
    1509             : void *
    1510     2359492 : palloc_aligned(Size size, Size alignto, int flags)
    1511             : {
    1512     2359492 :     return MemoryContextAllocAligned(CurrentMemoryContext, size, alignto, flags);
    1513             : }
    1514             : 
    1515             : /*
    1516             :  * pfree
    1517             :  *      Release an allocated chunk.
    1518             :  */
    1519             : void
    1520   371534606 : pfree(void *pointer)
    1521             : {
    1522             : #ifdef USE_VALGRIND
    1523             :     MemoryContextMethodID method = GetMemoryChunkMethodID(pointer);
    1524             :     MemoryContext context = GetMemoryChunkContext(pointer);
    1525             : #endif
    1526             : 
    1527   371534606 :     MCXT_METHOD(pointer, free_p) (pointer);
    1528             : 
    1529             : #ifdef USE_VALGRIND
    1530             :     if (method != MCTX_ALIGNED_REDIRECT_ID)
    1531             :         VALGRIND_MEMPOOL_FREE(context, pointer);
    1532             : #endif
    1533   371534606 : }
    1534             : 
    1535             : /*
    1536             :  * repalloc
    1537             :  *      Adjust the size of a previously allocated chunk.
    1538             :  */
    1539             : void *
    1540     7567226 : repalloc(void *pointer, Size size)
    1541             : {
    1542             : #ifdef USE_VALGRIND
    1543             :     MemoryContextMethodID method = GetMemoryChunkMethodID(pointer);
    1544             : #endif
    1545             : #if defined(USE_ASSERT_CHECKING) || defined(USE_VALGRIND)
    1546             :     MemoryContext context = GetMemoryChunkContext(pointer);
    1547             : #endif
    1548             :     void       *ret;
    1549             : 
    1550             :     AssertNotInCriticalSection(context);
    1551             : 
    1552             :     /* isReset must be false already */
    1553             :     Assert(!context->isReset);
    1554             : 
    1555             :     /*
    1556             :      * For efficiency reasons, we purposefully offload the handling of
    1557             :      * allocation failures to the MemoryContextMethods implementation as this
    1558             :      * allows these checks to be performed only when an actual malloc needs to
    1559             :      * be done to request more memory from the OS.  Additionally, not having
    1560             :      * to execute any instructions after this call allows the compiler to use
    1561             :      * the sibling call optimization.  If you're considering adding code after
    1562             :      * this call, consider making it the responsibility of the 'realloc'
    1563             :      * function instead.
    1564             :      */
    1565     7567226 :     ret = MCXT_METHOD(pointer, realloc) (pointer, size, 0);
    1566             : 
    1567             : #ifdef USE_VALGRIND
    1568             :     if (method != MCTX_ALIGNED_REDIRECT_ID)
    1569             :         VALGRIND_MEMPOOL_CHANGE(context, pointer, ret, size);
    1570             : #endif
    1571             : 
    1572     7567226 :     return ret;
    1573             : }
    1574             : 
    1575             : /*
    1576             :  * repalloc_extended
    1577             :  *      Adjust the size of a previously allocated chunk,
    1578             :  *      with HUGE and NO_OOM options.
    1579             :  */
    1580             : void *
    1581       86554 : repalloc_extended(void *pointer, Size size, int flags)
    1582             : {
    1583             : #if defined(USE_ASSERT_CHECKING) || defined(USE_VALGRIND)
    1584             :     MemoryContext context = GetMemoryChunkContext(pointer);
    1585             : #endif
    1586             :     void       *ret;
    1587             : 
    1588             :     AssertNotInCriticalSection(context);
    1589             : 
    1590             :     /* isReset must be false already */
    1591             :     Assert(!context->isReset);
    1592             : 
    1593             :     /*
    1594             :      * For efficiency reasons, we purposefully offload the handling of
    1595             :      * allocation failures to the MemoryContextMethods implementation as this
    1596             :      * allows these checks to be performed only when an actual malloc needs to
    1597             :      * be done to request more memory from the OS.  Additionally, not having
    1598             :      * to execute any instructions after this call allows the compiler to use
    1599             :      * the sibling call optimization.  If you're considering adding code after
    1600             :      * this call, consider making it the responsibility of the 'realloc'
    1601             :      * function instead.
    1602             :      */
    1603       86554 :     ret = MCXT_METHOD(pointer, realloc) (pointer, size, flags);
    1604       86554 :     if (unlikely(ret == NULL))
    1605           0 :         return NULL;
    1606             : 
    1607             :     VALGRIND_MEMPOOL_CHANGE(context, pointer, ret, size);
    1608             : 
    1609       86554 :     return ret;
    1610             : }
    1611             : 
    1612             : /*
    1613             :  * repalloc0
    1614             :  *      Adjust the size of a previously allocated chunk and zero out the added
    1615             :  *      space.
    1616             :  */
    1617             : void *
    1618       46516 : repalloc0(void *pointer, Size oldsize, Size size)
    1619             : {
    1620             :     void       *ret;
    1621             : 
    1622             :     /* catch wrong argument order */
    1623       46516 :     if (unlikely(oldsize > size))
    1624           0 :         elog(ERROR, "invalid repalloc0 call: oldsize %zu, new size %zu",
    1625             :              oldsize, size);
    1626             : 
    1627       46516 :     ret = repalloc(pointer, size);
    1628       46516 :     memset((char *) ret + oldsize, 0, (size - oldsize));
    1629       46516 :     return ret;
    1630             : }
    1631             : 
    1632             : /*
    1633             :  * MemoryContextAllocHuge
    1634             :  *      Allocate (possibly-expansive) space within the specified context.
    1635             :  *
    1636             :  * See considerations in comment at MaxAllocHugeSize.
    1637             :  */
    1638             : void *
    1639        2376 : MemoryContextAllocHuge(MemoryContext context, Size size)
    1640             : {
    1641             :     void       *ret;
    1642             : 
    1643             :     Assert(MemoryContextIsValid(context));
    1644             :     AssertNotInCriticalSection(context);
    1645             : 
    1646        2376 :     context->isReset = false;
    1647             : 
    1648             :     /*
    1649             :      * For efficiency reasons, we purposefully offload the handling of
    1650             :      * allocation failures to the MemoryContextMethods implementation as this
    1651             :      * allows these checks to be performed only when an actual malloc needs to
    1652             :      * be done to request more memory from the OS.  Additionally, not having
    1653             :      * to execute any instructions after this call allows the compiler to use
    1654             :      * the sibling call optimization.  If you're considering adding code after
    1655             :      * this call, consider making it the responsibility of the 'alloc'
    1656             :      * function instead.
    1657             :      */
    1658        2376 :     ret = context->methods->alloc(context, size, MCXT_ALLOC_HUGE);
    1659             : 
    1660             :     VALGRIND_MEMPOOL_ALLOC(context, ret, size);
    1661             : 
    1662        2376 :     return ret;
    1663             : }
    1664             : 
    1665             : /*
    1666             :  * repalloc_huge
    1667             :  *      Adjust the size of a previously allocated chunk, permitting a large
    1668             :  *      value.  The previous allocation need not have been "huge".
    1669             :  */
    1670             : void *
    1671       85800 : repalloc_huge(void *pointer, Size size)
    1672             : {
    1673             :     /* this one seems not worth its own implementation */
    1674       85800 :     return repalloc_extended(pointer, size, MCXT_ALLOC_HUGE);
    1675             : }
    1676             : 
    1677             : /*
    1678             :  * MemoryContextStrdup
    1679             :  *      Like strdup(), but allocate from the specified context
    1680             :  */
    1681             : char *
    1682    71611120 : MemoryContextStrdup(MemoryContext context, const char *string)
    1683             : {
    1684             :     char       *nstr;
    1685    71611120 :     Size        len = strlen(string) + 1;
    1686             : 
    1687    71611120 :     nstr = (char *) MemoryContextAlloc(context, len);
    1688             : 
    1689    71611120 :     memcpy(nstr, string, len);
    1690             : 
    1691    71611120 :     return nstr;
    1692             : }
    1693             : 
    1694             : char *
    1695    69020070 : pstrdup(const char *in)
    1696             : {
    1697    69020070 :     return MemoryContextStrdup(CurrentMemoryContext, in);
    1698             : }
    1699             : 
    1700             : /*
    1701             :  * pnstrdup
    1702             :  *      Like pstrdup(), but append null byte to a
    1703             :  *      not-necessarily-null-terminated input string.
    1704             :  */
    1705             : char *
    1706     1289834 : pnstrdup(const char *in, Size len)
    1707             : {
    1708             :     char       *out;
    1709             : 
    1710     1289834 :     len = strnlen(in, len);
    1711             : 
    1712     1289834 :     out = palloc(len + 1);
    1713     1289834 :     memcpy(out, in, len);
    1714     1289834 :     out[len] = '\0';
    1715             : 
    1716     1289834 :     return out;
    1717             : }
    1718             : 
    1719             : /*
    1720             :  * Make copy of string with all trailing newline characters removed.
    1721             :  */
    1722             : char *
    1723         322 : pchomp(const char *in)
    1724             : {
    1725             :     size_t      n;
    1726             : 
    1727         322 :     n = strlen(in);
    1728         644 :     while (n > 0 && in[n - 1] == '\n')
    1729         322 :         n--;
    1730         322 :     return pnstrdup(in, n);
    1731             : }

Generated by: LCOV version 1.14