1224 lines
33 KiB
C
1224 lines
33 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* mcxt.c
|
|
* POSTGRES memory context management code.
|
|
*
|
|
* This module handles context management operations that are independent
|
|
* of the particular kind of context being operated on. It calls
|
|
* context-type-specific operations via the function pointers in a
|
|
* context's MemoryContextMethods struct.
|
|
*
|
|
*
|
|
* Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
*
|
|
*
|
|
* IDENTIFICATION
|
|
* src/backend/utils/mmgr/mcxt.c
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "postgres.h"
|
|
|
|
#include "mb/pg_wchar.h"
|
|
#include "miscadmin.h"
|
|
#include "utils/memdebug.h"
|
|
#include "utils/memutils.h"
|
|
|
|
|
|
/*****************************************************************************
|
|
* GLOBAL MEMORY *
|
|
*****************************************************************************/
|
|
|
|
/*
|
|
* CurrentMemoryContext
|
|
* Default memory context for allocations.
|
|
*/
|
|
MemoryContext CurrentMemoryContext = NULL;
|
|
|
|
/*
|
|
* Standard top-level contexts. For a description of the purpose of each
|
|
* of these contexts, refer to src/backend/utils/mmgr/README
|
|
*/
|
|
MemoryContext TopMemoryContext = NULL;
|
|
MemoryContext ErrorContext = NULL;
|
|
MemoryContext PostmasterContext = NULL;
|
|
MemoryContext CacheMemoryContext = NULL;
|
|
MemoryContext MessageContext = NULL;
|
|
MemoryContext TopTransactionContext = NULL;
|
|
MemoryContext CurTransactionContext = NULL;
|
|
|
|
/* This is a transient link to the active portal's memory context: */
|
|
MemoryContext PortalContext = NULL;
|
|
|
|
static void MemoryContextCallResetCallbacks(MemoryContext context);
|
|
static void MemoryContextStatsInternal(MemoryContext context, int level,
|
|
bool print, int max_children,
|
|
MemoryContextCounters *totals);
|
|
static void MemoryContextStatsPrint(MemoryContext context, void *passthru,
|
|
const char *stats_string);
|
|
|
|
/*
|
|
* You should not do memory allocations within a critical section, because
|
|
* an out-of-memory error will be escalated to a PANIC. To enforce that
|
|
* rule, the allocation functions Assert that.
|
|
*/
|
|
#define AssertNotInCriticalSection(context) \
|
|
Assert(CritSectionCount == 0 || (context)->allowInCritSection)
|
|
|
|
|
|
/*****************************************************************************
|
|
* EXPORTED ROUTINES *
|
|
*****************************************************************************/
|
|
|
|
|
|
/*
|
|
* MemoryContextInit
|
|
* Start up the memory-context subsystem.
|
|
*
|
|
* This must be called before creating contexts or allocating memory in
|
|
* contexts. TopMemoryContext and ErrorContext are initialized here;
|
|
* other contexts must be created afterwards.
|
|
*
|
|
* In normal multi-backend operation, this is called once during
|
|
* postmaster startup, and not at all by individual backend startup
|
|
* (since the backends inherit an already-initialized context subsystem
|
|
* by virtue of being forked off the postmaster). But in an EXEC_BACKEND
|
|
* build, each process must do this for itself.
|
|
*
|
|
* In a standalone backend this must be called during backend startup.
|
|
*/
|
|
void
|
|
MemoryContextInit(void)
|
|
{
|
|
AssertState(TopMemoryContext == NULL);
|
|
|
|
/*
|
|
* First, initialize TopMemoryContext, which is the parent of all others.
|
|
*/
|
|
TopMemoryContext = AllocSetContextCreate((MemoryContext) NULL,
|
|
"TopMemoryContext",
|
|
ALLOCSET_DEFAULT_SIZES);
|
|
|
|
/*
|
|
* Not having any other place to point CurrentMemoryContext, make it point
|
|
* to TopMemoryContext. Caller should change this soon!
|
|
*/
|
|
CurrentMemoryContext = TopMemoryContext;
|
|
|
|
/*
|
|
* Initialize ErrorContext as an AllocSetContext with slow growth rate ---
|
|
* we don't really expect much to be allocated in it. More to the point,
|
|
* require it to contain at least 8K at all times. This is the only case
|
|
* where retained memory in a context is *essential* --- we want to be
|
|
* sure ErrorContext still has some memory even if we've run out
|
|
* elsewhere! Also, allow allocations in ErrorContext within a critical
|
|
* section. Otherwise a PANIC will cause an assertion failure in the error
|
|
* reporting code, before printing out the real cause of the failure.
|
|
*
|
|
* This should be the last step in this function, as elog.c assumes memory
|
|
* management works once ErrorContext is non-null.
|
|
*/
|
|
ErrorContext = AllocSetContextCreate(TopMemoryContext,
|
|
"ErrorContext",
|
|
8 * 1024,
|
|
8 * 1024,
|
|
8 * 1024);
|
|
MemoryContextAllowInCriticalSection(ErrorContext, true);
|
|
}
|
|
|
|
/*
|
|
* MemoryContextReset
|
|
* Release all space allocated within a context and delete all its
|
|
* descendant contexts (but not the named context itself).
|
|
*/
|
|
void
|
|
MemoryContextReset(MemoryContext context)
|
|
{
|
|
AssertArg(MemoryContextIsValid(context));
|
|
|
|
/* save a function call in common case where there are no children */
|
|
if (context->firstchild != NULL)
|
|
MemoryContextDeleteChildren(context);
|
|
|
|
/* save a function call if no pallocs since startup or last reset */
|
|
if (!context->isReset)
|
|
MemoryContextResetOnly(context);
|
|
}
|
|
|
|
/*
|
|
* MemoryContextResetOnly
|
|
* Release all space allocated within a context.
|
|
* Nothing is done to the context's descendant contexts.
|
|
*/
|
|
void
|
|
MemoryContextResetOnly(MemoryContext context)
|
|
{
|
|
AssertArg(MemoryContextIsValid(context));
|
|
|
|
/* Nothing to do if no pallocs since startup or last reset */
|
|
if (!context->isReset)
|
|
{
|
|
MemoryContextCallResetCallbacks(context);
|
|
|
|
/*
|
|
* If context->ident points into the context's memory, it will become
|
|
* a dangling pointer. We could prevent that by setting it to NULL
|
|
* here, but that would break valid coding patterns that keep the
|
|
* ident elsewhere, e.g. in a parent context. Another idea is to use
|
|
* MemoryContextContains(), but we don't require ident strings to be
|
|
* in separately-palloc'd chunks, so that risks false positives. So
|
|
* for now we assume the programmer got it right.
|
|
*/
|
|
|
|
context->methods->reset(context);
|
|
context->isReset = true;
|
|
VALGRIND_DESTROY_MEMPOOL(context);
|
|
VALGRIND_CREATE_MEMPOOL(context, 0, false);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* MemoryContextResetChildren
|
|
* Release all space allocated within a context's descendants,
|
|
* but don't delete the contexts themselves. The named context
|
|
* itself is not touched.
|
|
*/
|
|
void
|
|
MemoryContextResetChildren(MemoryContext context)
|
|
{
|
|
MemoryContext child;
|
|
|
|
AssertArg(MemoryContextIsValid(context));
|
|
|
|
for (child = context->firstchild; child != NULL; child = child->nextchild)
|
|
{
|
|
MemoryContextResetChildren(child);
|
|
MemoryContextResetOnly(child);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* MemoryContextDelete
|
|
* Delete a context and its descendants, and release all space
|
|
* allocated therein.
|
|
*
|
|
* The type-specific delete routine removes all storage for the context,
|
|
* but we have to recurse to handle the children.
|
|
* We must also delink the context from its parent, if it has one.
|
|
*/
|
|
void
|
|
MemoryContextDelete(MemoryContext context)
|
|
{
|
|
AssertArg(MemoryContextIsValid(context));
|
|
/* We had better not be deleting TopMemoryContext ... */
|
|
Assert(context != TopMemoryContext);
|
|
/* And not CurrentMemoryContext, either */
|
|
Assert(context != CurrentMemoryContext);
|
|
|
|
/* save a function call in common case where there are no children */
|
|
if (context->firstchild != NULL)
|
|
MemoryContextDeleteChildren(context);
|
|
|
|
/*
|
|
* It's not entirely clear whether 'tis better to do this before or after
|
|
* delinking the context; but an error in a callback will likely result in
|
|
* leaking the whole context (if it's not a root context) if we do it
|
|
* after, so let's do it before.
|
|
*/
|
|
MemoryContextCallResetCallbacks(context);
|
|
|
|
/*
|
|
* We delink the context from its parent before deleting it, so that if
|
|
* there's an error we won't have deleted/busted contexts still attached
|
|
* to the context tree. Better a leak than a crash.
|
|
*/
|
|
MemoryContextSetParent(context, NULL);
|
|
|
|
/*
|
|
* Also reset the context's ident pointer, in case it points into the
|
|
* context. This would only matter if someone tries to get stats on the
|
|
* (already unlinked) context, which is unlikely, but let's be safe.
|
|
*/
|
|
context->ident = NULL;
|
|
|
|
context->methods->delete_context(context);
|
|
|
|
VALGRIND_DESTROY_MEMPOOL(context);
|
|
}
|
|
|
|
/*
|
|
* MemoryContextDeleteChildren
|
|
* Delete all the descendants of the named context and release all
|
|
* space allocated therein. The named context itself is not touched.
|
|
*/
|
|
void
|
|
MemoryContextDeleteChildren(MemoryContext context)
|
|
{
|
|
AssertArg(MemoryContextIsValid(context));
|
|
|
|
/*
|
|
* MemoryContextDelete will delink the child from me, so just iterate as
|
|
* long as there is a child.
|
|
*/
|
|
while (context->firstchild != NULL)
|
|
MemoryContextDelete(context->firstchild);
|
|
}
|
|
|
|
/*
|
|
* MemoryContextRegisterResetCallback
|
|
* Register a function to be called before next context reset/delete.
|
|
* Such callbacks will be called in reverse order of registration.
|
|
*
|
|
* The caller is responsible for allocating a MemoryContextCallback struct
|
|
* to hold the info about this callback request, and for filling in the
|
|
* "func" and "arg" fields in the struct to show what function to call with
|
|
* what argument. Typically the callback struct should be allocated within
|
|
* the specified context, since that means it will automatically be freed
|
|
* when no longer needed.
|
|
*
|
|
* There is no API for deregistering a callback once registered. If you
|
|
* want it to not do anything anymore, adjust the state pointed to by its
|
|
* "arg" to indicate that.
|
|
*/
|
|
void
|
|
MemoryContextRegisterResetCallback(MemoryContext context,
|
|
MemoryContextCallback *cb)
|
|
{
|
|
AssertArg(MemoryContextIsValid(context));
|
|
|
|
/* Push onto head so this will be called before older registrants. */
|
|
cb->next = context->reset_cbs;
|
|
context->reset_cbs = cb;
|
|
/* Mark the context as non-reset (it probably is already). */
|
|
context->isReset = false;
|
|
}
|
|
|
|
/*
|
|
* MemoryContextCallResetCallbacks
|
|
* Internal function to call all registered callbacks for context.
|
|
*/
|
|
static void
|
|
MemoryContextCallResetCallbacks(MemoryContext context)
|
|
{
|
|
MemoryContextCallback *cb;
|
|
|
|
/*
|
|
* We pop each callback from the list before calling. That way, if an
|
|
* error occurs inside the callback, we won't try to call it a second time
|
|
* in the likely event that we reset or delete the context later.
|
|
*/
|
|
while ((cb = context->reset_cbs) != NULL)
|
|
{
|
|
context->reset_cbs = cb->next;
|
|
cb->func(cb->arg);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* MemoryContextSetIdentifier
|
|
* Set the identifier string for a memory context.
|
|
*
|
|
* An identifier can be provided to help distinguish among different contexts
|
|
* of the same kind in memory context stats dumps. The identifier string
|
|
* must live at least as long as the context it is for; typically it is
|
|
* allocated inside that context, so that it automatically goes away on
|
|
* context deletion. Pass id = NULL to forget any old identifier.
|
|
*/
|
|
void
|
|
MemoryContextSetIdentifier(MemoryContext context, const char *id)
|
|
{
|
|
AssertArg(MemoryContextIsValid(context));
|
|
context->ident = id;
|
|
}
|
|
|
|
/*
|
|
* MemoryContextSetParent
|
|
* Change a context to belong to a new parent (or no parent).
|
|
*
|
|
* We provide this as an API function because it is sometimes useful to
|
|
* change a context's lifespan after creation. For example, a context
|
|
* might be created underneath a transient context, filled with data,
|
|
* and then reparented underneath CacheMemoryContext to make it long-lived.
|
|
* In this way no special effort is needed to get rid of the context in case
|
|
* a failure occurs before its contents are completely set up.
|
|
*
|
|
* Callers often assume that this function cannot fail, so don't put any
|
|
* elog(ERROR) calls in it.
|
|
*
|
|
* A possible caller error is to reparent a context under itself, creating
|
|
* a loop in the context graph. We assert here that context != new_parent,
|
|
* but checking for multi-level loops seems more trouble than it's worth.
|
|
*/
|
|
void
|
|
MemoryContextSetParent(MemoryContext context, MemoryContext new_parent)
|
|
{
|
|
AssertArg(MemoryContextIsValid(context));
|
|
AssertArg(context != new_parent);
|
|
|
|
/* Fast path if it's got correct parent already */
|
|
if (new_parent == context->parent)
|
|
return;
|
|
|
|
/* Delink from existing parent, if any */
|
|
if (context->parent)
|
|
{
|
|
MemoryContext parent = context->parent;
|
|
|
|
if (context->prevchild != NULL)
|
|
context->prevchild->nextchild = context->nextchild;
|
|
else
|
|
{
|
|
Assert(parent->firstchild == context);
|
|
parent->firstchild = context->nextchild;
|
|
}
|
|
|
|
if (context->nextchild != NULL)
|
|
context->nextchild->prevchild = context->prevchild;
|
|
}
|
|
|
|
/* And relink */
|
|
if (new_parent)
|
|
{
|
|
AssertArg(MemoryContextIsValid(new_parent));
|
|
context->parent = new_parent;
|
|
context->prevchild = NULL;
|
|
context->nextchild = new_parent->firstchild;
|
|
if (new_parent->firstchild != NULL)
|
|
new_parent->firstchild->prevchild = context;
|
|
new_parent->firstchild = context;
|
|
}
|
|
else
|
|
{
|
|
context->parent = NULL;
|
|
context->prevchild = NULL;
|
|
context->nextchild = NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* MemoryContextAllowInCriticalSection
|
|
* Allow/disallow allocations in this memory context within a critical
|
|
* section.
|
|
*
|
|
* Normally, memory allocations are not allowed within a critical section,
|
|
* because a failure would lead to PANIC. There are a few exceptions to
|
|
* that, like allocations related to debugging code that is not supposed to
|
|
* be enabled in production. This function can be used to exempt specific
|
|
* memory contexts from the assertion in palloc().
|
|
*/
|
|
void
|
|
MemoryContextAllowInCriticalSection(MemoryContext context, bool allow)
|
|
{
|
|
AssertArg(MemoryContextIsValid(context));
|
|
|
|
context->allowInCritSection = allow;
|
|
}
|
|
|
|
/*
|
|
* GetMemoryChunkSpace
|
|
* Given a currently-allocated chunk, determine the total space
|
|
* it occupies (including all memory-allocation overhead).
|
|
*
|
|
* This is useful for measuring the total space occupied by a set of
|
|
* allocated chunks.
|
|
*/
|
|
Size
|
|
GetMemoryChunkSpace(void *pointer)
|
|
{
|
|
MemoryContext context = GetMemoryChunkContext(pointer);
|
|
|
|
return context->methods->get_chunk_space(context, pointer);
|
|
}
|
|
|
|
/*
|
|
* MemoryContextGetParent
|
|
* Get the parent context (if any) of the specified context
|
|
*/
|
|
MemoryContext
|
|
MemoryContextGetParent(MemoryContext context)
|
|
{
|
|
AssertArg(MemoryContextIsValid(context));
|
|
|
|
return context->parent;
|
|
}
|
|
|
|
/*
|
|
* MemoryContextIsEmpty
|
|
* Is a memory context empty of any allocated space?
|
|
*/
|
|
bool
|
|
MemoryContextIsEmpty(MemoryContext context)
|
|
{
|
|
AssertArg(MemoryContextIsValid(context));
|
|
|
|
/*
|
|
* For now, we consider a memory context nonempty if it has any children;
|
|
* perhaps this should be changed later.
|
|
*/
|
|
if (context->firstchild != NULL)
|
|
return false;
|
|
/* Otherwise use the type-specific inquiry */
|
|
return context->methods->is_empty(context);
|
|
}
|
|
|
|
/*
|
|
* Find the memory allocated to blocks for this memory context. If recurse is
|
|
* true, also include children.
|
|
*/
|
|
Size
|
|
MemoryContextMemAllocated(MemoryContext context, bool recurse)
|
|
{
|
|
Size total = context->mem_allocated;
|
|
|
|
AssertArg(MemoryContextIsValid(context));
|
|
|
|
if (recurse)
|
|
{
|
|
MemoryContext child = context->firstchild;
|
|
|
|
for (child = context->firstchild;
|
|
child != NULL;
|
|
child = child->nextchild)
|
|
total += MemoryContextMemAllocated(child, true);
|
|
}
|
|
|
|
return total;
|
|
}
|
|
|
|
/*
|
|
* MemoryContextStats
|
|
* Print statistics about the named context and all its descendants.
|
|
*
|
|
* This is just a debugging utility, so it's not very fancy. However, we do
|
|
* make some effort to summarize when the output would otherwise be very long.
|
|
* The statistics are sent to stderr.
|
|
*/
|
|
void
|
|
MemoryContextStats(MemoryContext context)
|
|
{
|
|
/* A hard-wired limit on the number of children is usually good enough */
|
|
MemoryContextStatsDetail(context, 100);
|
|
}
|
|
|
|
/*
|
|
* MemoryContextStatsDetail
|
|
*
|
|
* Entry point for use if you want to vary the number of child contexts shown.
|
|
*/
|
|
void
|
|
MemoryContextStatsDetail(MemoryContext context, int max_children)
|
|
{
|
|
MemoryContextCounters grand_totals;
|
|
|
|
memset(&grand_totals, 0, sizeof(grand_totals));
|
|
|
|
MemoryContextStatsInternal(context, 0, true, max_children, &grand_totals);
|
|
|
|
fprintf(stderr,
|
|
"Grand total: %zu bytes in %zd blocks; %zu free (%zd chunks); %zu used\n",
|
|
grand_totals.totalspace, grand_totals.nblocks,
|
|
grand_totals.freespace, grand_totals.freechunks,
|
|
grand_totals.totalspace - grand_totals.freespace);
|
|
}
|
|
|
|
/*
|
|
* MemoryContextStatsInternal
|
|
* One recursion level for MemoryContextStats
|
|
*
|
|
* Print this context if print is true, but in any case accumulate counts into
|
|
* *totals (if given).
|
|
*/
|
|
static void
|
|
MemoryContextStatsInternal(MemoryContext context, int level,
|
|
bool print, int max_children,
|
|
MemoryContextCounters *totals)
|
|
{
|
|
MemoryContextCounters local_totals;
|
|
MemoryContext child;
|
|
int ichild;
|
|
|
|
AssertArg(MemoryContextIsValid(context));
|
|
|
|
/* Examine the context itself */
|
|
context->methods->stats(context,
|
|
print ? MemoryContextStatsPrint : NULL,
|
|
(void *) &level,
|
|
totals);
|
|
|
|
/*
|
|
* Examine children. If there are more than max_children of them, we do
|
|
* not print the rest explicitly, but just summarize them.
|
|
*/
|
|
memset(&local_totals, 0, sizeof(local_totals));
|
|
|
|
for (child = context->firstchild, ichild = 0;
|
|
child != NULL;
|
|
child = child->nextchild, ichild++)
|
|
{
|
|
if (ichild < max_children)
|
|
MemoryContextStatsInternal(child, level + 1,
|
|
print, max_children,
|
|
totals);
|
|
else
|
|
MemoryContextStatsInternal(child, level + 1,
|
|
false, max_children,
|
|
&local_totals);
|
|
}
|
|
|
|
/* Deal with excess children */
|
|
if (ichild > max_children)
|
|
{
|
|
if (print)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i <= level; i++)
|
|
fprintf(stderr, " ");
|
|
fprintf(stderr,
|
|
"%d more child contexts containing %zu total in %zd blocks; %zu free (%zd chunks); %zu used\n",
|
|
ichild - max_children,
|
|
local_totals.totalspace,
|
|
local_totals.nblocks,
|
|
local_totals.freespace,
|
|
local_totals.freechunks,
|
|
local_totals.totalspace - local_totals.freespace);
|
|
}
|
|
|
|
if (totals)
|
|
{
|
|
totals->nblocks += local_totals.nblocks;
|
|
totals->freechunks += local_totals.freechunks;
|
|
totals->totalspace += local_totals.totalspace;
|
|
totals->freespace += local_totals.freespace;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* MemoryContextStatsPrint
|
|
* Print callback used by MemoryContextStatsInternal
|
|
*
|
|
* For now, the passthru pointer just points to "int level"; later we might
|
|
* make that more complicated.
|
|
*/
|
|
static void
|
|
MemoryContextStatsPrint(MemoryContext context, void *passthru,
|
|
const char *stats_string)
|
|
{
|
|
int level = *(int *) passthru;
|
|
const char *name = context->name;
|
|
const char *ident = context->ident;
|
|
int i;
|
|
|
|
/*
|
|
* It seems preferable to label dynahash contexts with just the hash table
|
|
* name. Those are already unique enough, so the "dynahash" part isn't
|
|
* very helpful, and this way is more consistent with pre-v11 practice.
|
|
*/
|
|
if (ident && strcmp(name, "dynahash") == 0)
|
|
{
|
|
name = ident;
|
|
ident = NULL;
|
|
}
|
|
|
|
for (i = 0; i < level; i++)
|
|
fprintf(stderr, " ");
|
|
fprintf(stderr, "%s: %s", name, stats_string);
|
|
if (ident)
|
|
{
|
|
/*
|
|
* Some contexts may have very long identifiers (e.g., SQL queries).
|
|
* Arbitrarily truncate at 100 bytes, but be careful not to break
|
|
* multibyte characters. Also, replace ASCII control characters, such
|
|
* as newlines, with spaces.
|
|
*/
|
|
int idlen = strlen(ident);
|
|
bool truncated = false;
|
|
|
|
if (idlen > 100)
|
|
{
|
|
idlen = pg_mbcliplen(ident, idlen, 100);
|
|
truncated = true;
|
|
}
|
|
fprintf(stderr, ": ");
|
|
while (idlen-- > 0)
|
|
{
|
|
unsigned char c = *ident++;
|
|
|
|
if (c < ' ')
|
|
c = ' ';
|
|
fputc(c, stderr);
|
|
}
|
|
if (truncated)
|
|
fprintf(stderr, "...");
|
|
}
|
|
fputc('\n', stderr);
|
|
}
|
|
|
|
/*
|
|
* MemoryContextCheck
|
|
* Check all chunks in the named context.
|
|
*
|
|
* This is just a debugging utility, so it's not fancy.
|
|
*/
|
|
#ifdef MEMORY_CONTEXT_CHECKING
|
|
void
|
|
MemoryContextCheck(MemoryContext context)
|
|
{
|
|
MemoryContext child;
|
|
|
|
AssertArg(MemoryContextIsValid(context));
|
|
|
|
context->methods->check(context);
|
|
for (child = context->firstchild; child != NULL; child = child->nextchild)
|
|
MemoryContextCheck(child);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* MemoryContextContains
|
|
* Detect whether an allocated chunk of memory belongs to a given
|
|
* context or not.
|
|
*
|
|
* Caution: this test is reliable as long as 'pointer' does point to
|
|
* a chunk of memory allocated from *some* context. If 'pointer' points
|
|
* at memory obtained in some other way, there is a small chance of a
|
|
* false-positive result, since the bits right before it might look like
|
|
* a valid chunk header by chance.
|
|
*/
|
|
bool
|
|
MemoryContextContains(MemoryContext context, void *pointer)
|
|
{
|
|
MemoryContext ptr_context;
|
|
|
|
/*
|
|
* NB: Can't use GetMemoryChunkContext() here - that performs assertions
|
|
* that aren't acceptable here since we might be passed memory not
|
|
* allocated by any memory context.
|
|
*
|
|
* Try to detect bogus pointers handed to us, poorly though we can.
|
|
* Presumably, a pointer that isn't MAXALIGNED isn't pointing at an
|
|
* allocated chunk.
|
|
*/
|
|
if (pointer == NULL || pointer != (void *) MAXALIGN(pointer))
|
|
return false;
|
|
|
|
/*
|
|
* OK, it's probably safe to look at the context.
|
|
*/
|
|
ptr_context = *(MemoryContext *) (((char *) pointer) - sizeof(void *));
|
|
|
|
return ptr_context == context;
|
|
}
|
|
|
|
/*
|
|
* MemoryContextCreate
|
|
* Context-type-independent part of context creation.
|
|
*
|
|
* This is only intended to be called by context-type-specific
|
|
* context creation routines, not by the unwashed masses.
|
|
*
|
|
* The memory context creation procedure goes like this:
|
|
* 1. Context-type-specific routine makes some initial space allocation,
|
|
* including enough space for the context header. If it fails,
|
|
* it can ereport() with no damage done.
|
|
* 2. Context-type-specific routine sets up all type-specific fields of
|
|
* the header (those beyond MemoryContextData proper), as well as any
|
|
* other management fields it needs to have a fully valid context.
|
|
* Usually, failure in this step is impossible, but if it's possible
|
|
* the initial space allocation should be freed before ereport'ing.
|
|
* 3. Context-type-specific routine calls MemoryContextCreate() to fill in
|
|
* the generic header fields and link the context into the context tree.
|
|
* 4. We return to the context-type-specific routine, which finishes
|
|
* up type-specific initialization. This routine can now do things
|
|
* that might fail (like allocate more memory), so long as it's
|
|
* sure the node is left in a state that delete will handle.
|
|
*
|
|
* node: the as-yet-uninitialized common part of the context header node.
|
|
* tag: NodeTag code identifying the memory context type.
|
|
* methods: context-type-specific methods (usually statically allocated).
|
|
* parent: parent context, or NULL if this will be a top-level context.
|
|
* name: name of context (must be statically allocated).
|
|
*
|
|
* Context routines generally assume that MemoryContextCreate can't fail,
|
|
* so this can contain Assert but not elog/ereport.
|
|
*/
|
|
void
|
|
MemoryContextCreate(MemoryContext node,
|
|
NodeTag tag,
|
|
const MemoryContextMethods *methods,
|
|
MemoryContext parent,
|
|
const char *name)
|
|
{
|
|
/* Creating new memory contexts is not allowed in a critical section */
|
|
Assert(CritSectionCount == 0);
|
|
|
|
/* Initialize all standard fields of memory context header */
|
|
node->type = tag;
|
|
node->isReset = true;
|
|
node->methods = methods;
|
|
node->parent = parent;
|
|
node->firstchild = NULL;
|
|
node->mem_allocated = 0;
|
|
node->prevchild = NULL;
|
|
node->name = name;
|
|
node->ident = NULL;
|
|
node->reset_cbs = NULL;
|
|
|
|
/* OK to link node into context tree */
|
|
if (parent)
|
|
{
|
|
node->nextchild = parent->firstchild;
|
|
if (parent->firstchild != NULL)
|
|
parent->firstchild->prevchild = node;
|
|
parent->firstchild = node;
|
|
/* inherit allowInCritSection flag from parent */
|
|
node->allowInCritSection = parent->allowInCritSection;
|
|
}
|
|
else
|
|
{
|
|
node->nextchild = NULL;
|
|
node->allowInCritSection = false;
|
|
}
|
|
|
|
VALGRIND_CREATE_MEMPOOL(node, 0, false);
|
|
}
|
|
|
|
/*
|
|
* MemoryContextAlloc
|
|
* Allocate space within the specified context.
|
|
*
|
|
* This could be turned into a macro, but we'd have to import
|
|
* nodes/memnodes.h into postgres.h which seems a bad idea.
|
|
*/
|
|
void *
|
|
MemoryContextAlloc(MemoryContext context, Size size)
|
|
{
|
|
void *ret;
|
|
|
|
AssertArg(MemoryContextIsValid(context));
|
|
AssertNotInCriticalSection(context);
|
|
|
|
if (!AllocSizeIsValid(size))
|
|
elog(ERROR, "invalid memory alloc request size %zu", size);
|
|
|
|
context->isReset = false;
|
|
|
|
ret = context->methods->alloc(context, size);
|
|
if (unlikely(ret == NULL))
|
|
{
|
|
MemoryContextStats(TopMemoryContext);
|
|
|
|
/*
|
|
* Here, and elsewhere in this module, we show the target context's
|
|
* "name" but not its "ident" (if any) in user-visible error messages.
|
|
* The "ident" string might contain security-sensitive data, such as
|
|
* values in SQL commands.
|
|
*/
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_OUT_OF_MEMORY),
|
|
errmsg("out of memory"),
|
|
errdetail("Failed on request of size %zu in memory context \"%s\".",
|
|
size, context->name)));
|
|
}
|
|
|
|
VALGRIND_MEMPOOL_ALLOC(context, ret, size);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* MemoryContextAllocZero
|
|
* Like MemoryContextAlloc, but clears allocated memory
|
|
*
|
|
* We could just call MemoryContextAlloc then clear the memory, but this
|
|
* is a very common combination, so we provide the combined operation.
|
|
*/
|
|
void *
|
|
MemoryContextAllocZero(MemoryContext context, Size size)
|
|
{
|
|
void *ret;
|
|
|
|
AssertArg(MemoryContextIsValid(context));
|
|
AssertNotInCriticalSection(context);
|
|
|
|
if (!AllocSizeIsValid(size))
|
|
elog(ERROR, "invalid memory alloc request size %zu", size);
|
|
|
|
context->isReset = false;
|
|
|
|
ret = context->methods->alloc(context, size);
|
|
if (unlikely(ret == NULL))
|
|
{
|
|
MemoryContextStats(TopMemoryContext);
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_OUT_OF_MEMORY),
|
|
errmsg("out of memory"),
|
|
errdetail("Failed on request of size %zu in memory context \"%s\".",
|
|
size, context->name)));
|
|
}
|
|
|
|
VALGRIND_MEMPOOL_ALLOC(context, ret, size);
|
|
|
|
MemSetAligned(ret, 0, size);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* MemoryContextAllocZeroAligned
|
|
* MemoryContextAllocZero where length is suitable for MemSetLoop
|
|
*
|
|
* This might seem overly specialized, but it's not because newNode()
|
|
* is so often called with compile-time-constant sizes.
|
|
*/
|
|
void *
|
|
MemoryContextAllocZeroAligned(MemoryContext context, Size size)
|
|
{
|
|
void *ret;
|
|
|
|
AssertArg(MemoryContextIsValid(context));
|
|
AssertNotInCriticalSection(context);
|
|
|
|
if (!AllocSizeIsValid(size))
|
|
elog(ERROR, "invalid memory alloc request size %zu", size);
|
|
|
|
context->isReset = false;
|
|
|
|
ret = context->methods->alloc(context, size);
|
|
if (unlikely(ret == NULL))
|
|
{
|
|
MemoryContextStats(TopMemoryContext);
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_OUT_OF_MEMORY),
|
|
errmsg("out of memory"),
|
|
errdetail("Failed on request of size %zu in memory context \"%s\".",
|
|
size, context->name)));
|
|
}
|
|
|
|
VALGRIND_MEMPOOL_ALLOC(context, ret, size);
|
|
|
|
MemSetLoop(ret, 0, size);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* MemoryContextAllocExtended
|
|
* Allocate space within the specified context using the given flags.
|
|
*/
|
|
void *
|
|
MemoryContextAllocExtended(MemoryContext context, Size size, int flags)
|
|
{
|
|
void *ret;
|
|
|
|
AssertArg(MemoryContextIsValid(context));
|
|
AssertNotInCriticalSection(context);
|
|
|
|
if (((flags & MCXT_ALLOC_HUGE) != 0 && !AllocHugeSizeIsValid(size)) ||
|
|
((flags & MCXT_ALLOC_HUGE) == 0 && !AllocSizeIsValid(size)))
|
|
elog(ERROR, "invalid memory alloc request size %zu", size);
|
|
|
|
context->isReset = false;
|
|
|
|
ret = context->methods->alloc(context, size);
|
|
if (unlikely(ret == NULL))
|
|
{
|
|
if ((flags & MCXT_ALLOC_NO_OOM) == 0)
|
|
{
|
|
MemoryContextStats(TopMemoryContext);
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_OUT_OF_MEMORY),
|
|
errmsg("out of memory"),
|
|
errdetail("Failed on request of size %zu in memory context \"%s\".",
|
|
size, context->name)));
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
VALGRIND_MEMPOOL_ALLOC(context, ret, size);
|
|
|
|
if ((flags & MCXT_ALLOC_ZERO) != 0)
|
|
MemSetAligned(ret, 0, size);
|
|
|
|
return ret;
|
|
}
|
|
|
|
void *
|
|
palloc(Size size)
|
|
{
|
|
/* duplicates MemoryContextAlloc to avoid increased overhead */
|
|
void *ret;
|
|
MemoryContext context = CurrentMemoryContext;
|
|
|
|
AssertArg(MemoryContextIsValid(context));
|
|
AssertNotInCriticalSection(context);
|
|
|
|
if (!AllocSizeIsValid(size))
|
|
elog(ERROR, "invalid memory alloc request size %zu", size);
|
|
|
|
context->isReset = false;
|
|
|
|
ret = context->methods->alloc(context, size);
|
|
if (unlikely(ret == NULL))
|
|
{
|
|
MemoryContextStats(TopMemoryContext);
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_OUT_OF_MEMORY),
|
|
errmsg("out of memory"),
|
|
errdetail("Failed on request of size %zu in memory context \"%s\".",
|
|
size, context->name)));
|
|
}
|
|
|
|
VALGRIND_MEMPOOL_ALLOC(context, ret, size);
|
|
|
|
return ret;
|
|
}
|
|
|
|
void *
|
|
palloc0(Size size)
|
|
{
|
|
/* duplicates MemoryContextAllocZero to avoid increased overhead */
|
|
void *ret;
|
|
MemoryContext context = CurrentMemoryContext;
|
|
|
|
AssertArg(MemoryContextIsValid(context));
|
|
AssertNotInCriticalSection(context);
|
|
|
|
if (!AllocSizeIsValid(size))
|
|
elog(ERROR, "invalid memory alloc request size %zu", size);
|
|
|
|
context->isReset = false;
|
|
|
|
ret = context->methods->alloc(context, size);
|
|
if (unlikely(ret == NULL))
|
|
{
|
|
MemoryContextStats(TopMemoryContext);
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_OUT_OF_MEMORY),
|
|
errmsg("out of memory"),
|
|
errdetail("Failed on request of size %zu in memory context \"%s\".",
|
|
size, context->name)));
|
|
}
|
|
|
|
VALGRIND_MEMPOOL_ALLOC(context, ret, size);
|
|
|
|
MemSetAligned(ret, 0, size);
|
|
|
|
return ret;
|
|
}
|
|
|
|
void *
|
|
palloc_extended(Size size, int flags)
|
|
{
|
|
/* duplicates MemoryContextAllocExtended to avoid increased overhead */
|
|
void *ret;
|
|
MemoryContext context = CurrentMemoryContext;
|
|
|
|
AssertArg(MemoryContextIsValid(context));
|
|
AssertNotInCriticalSection(context);
|
|
|
|
if (((flags & MCXT_ALLOC_HUGE) != 0 && !AllocHugeSizeIsValid(size)) ||
|
|
((flags & MCXT_ALLOC_HUGE) == 0 && !AllocSizeIsValid(size)))
|
|
elog(ERROR, "invalid memory alloc request size %zu", size);
|
|
|
|
context->isReset = false;
|
|
|
|
ret = context->methods->alloc(context, size);
|
|
if (unlikely(ret == NULL))
|
|
{
|
|
if ((flags & MCXT_ALLOC_NO_OOM) == 0)
|
|
{
|
|
MemoryContextStats(TopMemoryContext);
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_OUT_OF_MEMORY),
|
|
errmsg("out of memory"),
|
|
errdetail("Failed on request of size %zu in memory context \"%s\".",
|
|
size, context->name)));
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
VALGRIND_MEMPOOL_ALLOC(context, ret, size);
|
|
|
|
if ((flags & MCXT_ALLOC_ZERO) != 0)
|
|
MemSetAligned(ret, 0, size);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* pfree
|
|
* Release an allocated chunk.
|
|
*/
|
|
void
|
|
pfree(void *pointer)
|
|
{
|
|
MemoryContext context = GetMemoryChunkContext(pointer);
|
|
|
|
context->methods->free_p(context, pointer);
|
|
VALGRIND_MEMPOOL_FREE(context, pointer);
|
|
}
|
|
|
|
/*
|
|
* repalloc
|
|
* Adjust the size of a previously allocated chunk.
|
|
*/
|
|
void *
|
|
repalloc(void *pointer, Size size)
|
|
{
|
|
MemoryContext context = GetMemoryChunkContext(pointer);
|
|
void *ret;
|
|
|
|
if (!AllocSizeIsValid(size))
|
|
elog(ERROR, "invalid memory alloc request size %zu", size);
|
|
|
|
AssertNotInCriticalSection(context);
|
|
|
|
/* isReset must be false already */
|
|
Assert(!context->isReset);
|
|
|
|
ret = context->methods->realloc(context, pointer, size);
|
|
if (unlikely(ret == NULL))
|
|
{
|
|
MemoryContextStats(TopMemoryContext);
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_OUT_OF_MEMORY),
|
|
errmsg("out of memory"),
|
|
errdetail("Failed on request of size %zu in memory context \"%s\".",
|
|
size, context->name)));
|
|
}
|
|
|
|
VALGRIND_MEMPOOL_CHANGE(context, pointer, ret, size);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* MemoryContextAllocHuge
|
|
* Allocate (possibly-expansive) space within the specified context.
|
|
*
|
|
* See considerations in comment at MaxAllocHugeSize.
|
|
*/
|
|
void *
|
|
MemoryContextAllocHuge(MemoryContext context, Size size)
|
|
{
|
|
void *ret;
|
|
|
|
AssertArg(MemoryContextIsValid(context));
|
|
AssertNotInCriticalSection(context);
|
|
|
|
if (!AllocHugeSizeIsValid(size))
|
|
elog(ERROR, "invalid memory alloc request size %zu", size);
|
|
|
|
context->isReset = false;
|
|
|
|
ret = context->methods->alloc(context, size);
|
|
if (unlikely(ret == NULL))
|
|
{
|
|
MemoryContextStats(TopMemoryContext);
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_OUT_OF_MEMORY),
|
|
errmsg("out of memory"),
|
|
errdetail("Failed on request of size %zu in memory context \"%s\".",
|
|
size, context->name)));
|
|
}
|
|
|
|
VALGRIND_MEMPOOL_ALLOC(context, ret, size);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* repalloc_huge
|
|
* Adjust the size of a previously allocated chunk, permitting a large
|
|
* value. The previous allocation need not have been "huge".
|
|
*/
|
|
void *
|
|
repalloc_huge(void *pointer, Size size)
|
|
{
|
|
MemoryContext context = GetMemoryChunkContext(pointer);
|
|
void *ret;
|
|
|
|
if (!AllocHugeSizeIsValid(size))
|
|
elog(ERROR, "invalid memory alloc request size %zu", size);
|
|
|
|
AssertNotInCriticalSection(context);
|
|
|
|
/* isReset must be false already */
|
|
Assert(!context->isReset);
|
|
|
|
ret = context->methods->realloc(context, pointer, size);
|
|
if (unlikely(ret == NULL))
|
|
{
|
|
MemoryContextStats(TopMemoryContext);
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_OUT_OF_MEMORY),
|
|
errmsg("out of memory"),
|
|
errdetail("Failed on request of size %zu in memory context \"%s\".",
|
|
size, context->name)));
|
|
}
|
|
|
|
VALGRIND_MEMPOOL_CHANGE(context, pointer, ret, size);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* MemoryContextStrdup
|
|
* Like strdup(), but allocate from the specified context
|
|
*/
|
|
char *
|
|
MemoryContextStrdup(MemoryContext context, const char *string)
|
|
{
|
|
char *nstr;
|
|
Size len = strlen(string) + 1;
|
|
|
|
nstr = (char *) MemoryContextAlloc(context, len);
|
|
|
|
memcpy(nstr, string, len);
|
|
|
|
return nstr;
|
|
}
|
|
|
|
char *
|
|
pstrdup(const char *in)
|
|
{
|
|
return MemoryContextStrdup(CurrentMemoryContext, in);
|
|
}
|
|
|
|
/*
|
|
* pnstrdup
|
|
* Like pstrdup(), but append null byte to a
|
|
* not-necessarily-null-terminated input string.
|
|
*/
|
|
char *
|
|
pnstrdup(const char *in, Size len)
|
|
{
|
|
char *out;
|
|
|
|
len = strnlen(in, len);
|
|
|
|
out = palloc(len + 1);
|
|
memcpy(out, in, len);
|
|
out[len] = '\0';
|
|
|
|
return out;
|
|
}
|
|
|
|
/*
|
|
* Make copy of string with all trailing newline characters removed.
|
|
*/
|
|
char *
|
|
pchomp(const char *in)
|
|
{
|
|
size_t n;
|
|
|
|
n = strlen(in);
|
|
while (n > 0 && in[n - 1] == '\n')
|
|
n--;
|
|
return pnstrdup(in, n);
|
|
}
|