2 files changed, 33 insertions, 642 deletions

diff --git a/src/backend/utils/mmgr/alignedalloc.c b/src/backend/utils/mmgr/alignedalloc.c
index 85aee389d6b..7eea695de62 100644
--- a/src/backend/utils/mmgr/alignedalloc.c
+++ b/src/backend/utils/mmgr/alignedalloc.c
@@ -45,6 +45,7 @@ AlignedAllocFree(void *pointer)
 			 GetMemoryChunkContext(unaligned)->name, chunk);
 #endif
 
+	/* Recursively pfree the unaligned chunk */
 	pfree(unaligned);
 }
 
@@ -96,18 +97,32 @@ AlignedAllocRealloc(void *pointer, Size size, int flags)
 	Assert(old_size >= redirchunk->requested_size);
 #endif
 
+	/*
+	 * To keep things simple, we always allocate a new aligned chunk and copy
+	 * data into it.  Because of the above inaccuracy, this may end in copying
+	 * more data than was in the original allocation request size, but that
+	 * should be OK.
+	 */
 	ctx = GetMemoryChunkContext(unaligned);
 	newptr = MemoryContextAllocAligned(ctx, size, alignto, flags);
 
-	/*
-	 * We may memcpy beyond the end of the original allocation request size,
-	 * so we must mark the entire allocation as defined.
-	 */
-	if (likely(newptr != NULL))
+	/* Cope cleanly with OOM */
+	if (unlikely(newptr == NULL))
 	{
-		VALGRIND_MAKE_MEM_DEFINED(pointer, old_size);
-		memcpy(newptr, pointer, Min(size, old_size));
+		VALGRIND_MAKE_MEM_NOACCESS(redirchunk, sizeof(MemoryChunk));
+		return MemoryContextAllocationFailure(ctx, size, flags);
 	}
+
+	/*
+	 * We may memcpy more than the original allocation request size, which
+	 * would result in trying to copy trailing bytes that the original
+	 * MemoryContextAllocAligned call marked NOACCESS.  So we must mark the
+	 * entire old_size as defined.  That's slightly annoying, but probably not
+	 * worth improving.
+	 */
+	VALGRIND_MAKE_MEM_DEFINED(pointer, old_size);
+	memcpy(newptr, pointer, Min(size, old_size));
+
 	pfree(unaligned);
 
 	return newptr;
diff --git a/src/backend/utils/mmgr/mcxt.c b/src/backend/utils/mmgr/mcxt.c
index 7d28ca706eb..15fa4d0a55e 100644
--- a/src/backend/utils/mmgr/mcxt.c
+++ b/src/backend/utils/mmgr/mcxt.c
@@ -23,11 +23,6 @@
 
 #include "mb/pg_wchar.h"
 #include "miscadmin.h"
-#include "nodes/pg_list.h"
-#include "storage/lwlock.h"
-#include "storage/ipc.h"
-#include "utils/dsa.h"
-#include "utils/hsearch.h"
 #include "utils/memdebug.h"
 #include "utils/memutils.h"
 #include "utils/memutils_internal.h"
@@ -140,17 +135,6 @@ static const MemoryContextMethods mcxt_methods[] = {
 };
 
 #undef BOGUS_MCTX
-/*
- * This is passed to MemoryContextStatsInternal to determine whether
- * to print context statistics or not and where to print them logs or
- * stderr.
- */
-typedef enum PrintDestination
-{
-	PRINT_STATS_TO_STDERR = 0,
-	PRINT_STATS_TO_LOGS,
-	PRINT_STATS_NONE
-}			PrintDestination;
 
 /*
  * CurrentMemoryContext
@@ -172,31 +156,16 @@ MemoryContext CurTransactionContext = NULL;
 
 /* This is a transient link to the active portal's memory context: */
 MemoryContext PortalContext = NULL;
-dsa_area   *MemoryStatsDsaArea = NULL;
 
 static void MemoryContextDeleteOnly(MemoryContext context);
 static void MemoryContextCallResetCallbacks(MemoryContext context);
 static void MemoryContextStatsInternal(MemoryContext context, int level,
 									   int max_level, int max_children,
 									   MemoryContextCounters *totals,
-									   PrintDestination print_location,
-									   int *num_contexts);
+									   bool print_to_stderr);
 static void MemoryContextStatsPrint(MemoryContext context, void *passthru,
 									const char *stats_string,
 									bool print_to_stderr);
-static void PublishMemoryContext(MemoryStatsEntry *memcxt_info,
-								 int curr_id, MemoryContext context,
-								 List *path,
-								 MemoryContextCounters stat,
-								 int num_contexts, dsa_area *area,
-								 int max_levels);
-static void compute_contexts_count_and_ids(List *contexts, HTAB *context_id_lookup,
-										   int *stats_count,
-										   bool summary);
-static List *compute_context_path(MemoryContext c, HTAB *context_id_lookup);
-static void free_memorycontextstate_dsa(dsa_area *area, int total_stats,
-										dsa_pointer prev_dsa_pointer);
-static void end_memorycontext_reporting(void);
 
 /*
  * You should not do memory allocations within a critical section, because
@@ -862,19 +831,11 @@ MemoryContextStatsDetail(MemoryContext context,
 						 bool print_to_stderr)
 {
 	MemoryContextCounters grand_totals;
-	int			num_contexts;
-	PrintDestination print_location;
 
 	memset(&grand_totals, 0, sizeof(grand_totals));
 
-	if (print_to_stderr)
-		print_location = PRINT_STATS_TO_STDERR;
-	else
-		print_location = PRINT_STATS_TO_LOGS;
-
-	/* num_contexts report number of contexts aggregated in the output */
 	MemoryContextStatsInternal(context, 1, max_level, max_children,
-							   &grand_totals, print_location, &num_contexts);
+							   &grand_totals, print_to_stderr);
 
 	if (print_to_stderr)
 		fprintf(stderr,
@@ -909,14 +870,13 @@ MemoryContextStatsDetail(MemoryContext context,
  *		One recursion level for MemoryContextStats
  *
  * Print stats for this context if possible, but in any case accumulate counts
- * into *totals (if not NULL). The callers should make sure that print_location
- * is set to PRINT_STATS_TO_STDERR or PRINT_STATS_TO_LOGS or PRINT_STATS_NONE.
+ * into *totals (if not NULL).
  */
 static void
 MemoryContextStatsInternal(MemoryContext context, int level,
 						   int max_level, int max_children,
 						   MemoryContextCounters *totals,
-						   PrintDestination print_location, int *num_contexts)
+						   bool print_to_stderr)
 {
 	MemoryContext child;
 	int			ichild;
@@ -924,39 +884,10 @@ MemoryContextStatsInternal(MemoryContext context, int level,
 	Assert(MemoryContextIsValid(context));
 
 	/* Examine the context itself */
-	switch (print_location)
-	{
-		case PRINT_STATS_TO_STDERR:
-			context->methods->stats(context,
-									MemoryContextStatsPrint,
-									&level,
-									totals, true);
-			break;
-
-		case PRINT_STATS_TO_LOGS:
-			context->methods->stats(context,
-									MemoryContextStatsPrint,
-									&level,
-									totals, false);
-			break;
-
-		case PRINT_STATS_NONE:
-
-			/*
-			 * Do not print the statistics if print_location is
-			 * PRINT_STATS_NONE, only compute totals. This is used in
-			 * reporting of memory context statistics via a sql function. Last
-			 * parameter is not relevant.
-			 */
-			context->methods->stats(context,
-									NULL,
-									NULL,
-									totals, false);
-			break;
-	}
-
-	/* Increment the context count for each of the recursive call */
-	*num_contexts = *num_contexts + 1;
+	context->methods->stats(context,
+							MemoryContextStatsPrint,
+							&level,
+							totals, print_to_stderr);
 
 	/*
 	 * Examine children.
@@ -976,7 +907,7 @@ MemoryContextStatsInternal(MemoryContext context, int level,
 			MemoryContextStatsInternal(child, level + 1,
 									   max_level, max_children,
 									   totals,
-									   print_location, num_contexts);
+									   print_to_stderr);
 		}
 	}
 
@@ -995,13 +926,7 @@ MemoryContextStatsInternal(MemoryContext context, int level,
 			child = MemoryContextTraverseNext(child, context);
 		}
 
-		/*
-		 * Add the count of children contexts which are traversed in the
-		 * non-recursive manner.
-		 */
-		*num_contexts = *num_contexts + ichild;
-
-		if (print_location == PRINT_STATS_TO_STDERR)
+		if (print_to_stderr)
 		{
 			for (int i = 0; i < level; i++)
 				fprintf(stderr, "  ");
@@ -1014,7 +939,7 @@ MemoryContextStatsInternal(MemoryContext context, int level,
 					local_totals.freechunks,
 					local_totals.totalspace - local_totals.freespace);
 		}
-		else if (print_location == PRINT_STATS_TO_LOGS)
+		else
 			ereport(LOG_SERVER_ONLY,
 					(errhidestmt(true),
 					 errhidecontext(true),
@@ -1356,22 +1281,6 @@ HandleLogMemoryContextInterrupt(void)
 }
 
 /*
- * HandleGetMemoryContextInterrupt
- *		Handle receipt of an interrupt indicating a request to publish memory
- *		contexts statistics.
- *
- * All the actual work is deferred to ProcessGetMemoryContextInterrupt() as
- * this cannot be performed in a signal handler.
- */
-void
-HandleGetMemoryContextInterrupt(void)
-{
-	InterruptPending = true;
-	PublishMemoryContextPending = true;
-	/* latch will be set by procsignal_sigusr1_handler */
-}
-
-/*
  * ProcessLogMemoryContextInterrupt
  * 		Perform logging of memory contexts of this backend process.
  *
@@ -1408,539 +1317,6 @@ ProcessLogMemoryContextInterrupt(void)
 	MemoryContextStatsDetail(TopMemoryContext, 100, 100, false);
 }
 
-/*
- * ProcessGetMemoryContextInterrupt
- *		Generate information about memory contexts used by the process.
- *
- * Performs a breadth first search on the memory context tree, thus parents
- * statistics are reported before their children in the monitoring function
- * output.
- *
- * Statistics for all the processes are shared via the same dynamic shared
- * area.  Statistics written by each process are tracked independently in
- * per-process DSA pointers. These pointers are stored in static shared memory.
- *
- * We calculate maximum number of context's statistics that can be displayed
- * using a pre-determined limit for memory available per process for this
- * utility maximum size of statistics for each context.  The remaining context
- * statistics if any are captured as a cumulative total at the end of
- * individual context's statistics.
- *
- * If summary is true, we capture the level 1 and level 2 contexts
- * statistics.  For that we traverse the memory context tree recursively in
- * depth first search manner to cover all the children of a parent context, to
- * be able to display a cumulative total of memory consumption by a parent at
- * level 2 and all its children.
- */
-void
-ProcessGetMemoryContextInterrupt(void)
-{
-	List	   *contexts;
-	HASHCTL		ctl;
-	HTAB	   *context_id_lookup;
-	int			context_id = 0;
-	MemoryStatsEntry *meminfo;
-	bool		summary = false;
-	int			max_stats;
-	int			idx = MyProcNumber;
-	int			stats_count = 0;
-	int			stats_num = 0;
-	MemoryContextCounters stat;
-	int			num_individual_stats = 0;
-
-	PublishMemoryContextPending = false;
-
-	/*
-	 * The hash table is used for constructing "path" column of the view,
-	 * similar to its local backend counterpart.
-	 */
-	ctl.keysize = sizeof(MemoryContext);
-	ctl.entrysize = sizeof(MemoryStatsContextId);
-	ctl.hcxt = CurrentMemoryContext;
-
-	context_id_lookup = hash_create("pg_get_remote_backend_memory_contexts",
-									256,
-									&ctl,
-									HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
-
-	/* List of contexts to process in the next round - start at the top. */
-	contexts = list_make1(TopMemoryContext);
-
-	/* Compute the number of stats that can fit in the defined limit */
-	max_stats =
-		MEMORY_CONTEXT_REPORT_MAX_PER_BACKEND / MAX_MEMORY_CONTEXT_STATS_SIZE;
-	LWLockAcquire(&memCxtState[idx].lw_lock, LW_EXCLUSIVE);
-	summary = memCxtState[idx].summary;
-	LWLockRelease(&memCxtState[idx].lw_lock);
-
-	/*
-	 * Traverse the memory context tree to find total number of contexts. If
-	 * summary is requested report the total number of contexts at level 1 and
-	 * 2 from the top. Also, populate the hash table of context ids.
-	 */
-	compute_contexts_count_and_ids(contexts, context_id_lookup, &stats_count,
-								   summary);
-
-	/*
-	 * Allocate memory in this process's DSA for storing statistics of the
-	 * memory contexts upto max_stats, for contexts that don't fit within a
-	 * limit, a cumulative total is written as the last record in the DSA
-	 * segment.
-	 */
-	stats_num = Min(stats_count, max_stats);
-
-	LWLockAcquire(&memCxtArea->lw_lock, LW_EXCLUSIVE);
-
-	/*
-	 * Create a DSA and send handle to the client process after storing the
-	 * context statistics. If number of contexts exceed a predefined limit
-	 * (1MB), a cumulative total is stored for such contexts.
-	 */
-	if (memCxtArea->memstats_dsa_handle == DSA_HANDLE_INVALID)
-	{
-		MemoryContext oldcontext = CurrentMemoryContext;
-		dsa_handle	handle;
-
-		MemoryContextSwitchTo(TopMemoryContext);
-
-		MemoryStatsDsaArea = dsa_create(memCxtArea->lw_lock.tranche);
-
-		handle = dsa_get_handle(MemoryStatsDsaArea);
-		MemoryContextSwitchTo(oldcontext);
-
-		dsa_pin_mapping(MemoryStatsDsaArea);
-
-		/*
-		 * Pin the DSA area, this is to make sure the area remains attachable
-		 * even if the backend that created it exits. This is done so that the
-		 * statistics are published even if the process exits while a client
-		 * is waiting. Also, other processes that publish statistics will use
-		 * the same area.
-		 */
-		dsa_pin(MemoryStatsDsaArea);
-
-		/* Set the handle in shared memory */
-		memCxtArea->memstats_dsa_handle = handle;
-	}
-
-	/*
-	 * If DSA exists, created by another process publishing statistics, attach
-	 * to it.
-	 */
-	else if (MemoryStatsDsaArea == NULL)
-	{
-		MemoryContext oldcontext = CurrentMemoryContext;
-
-		MemoryContextSwitchTo(TopMemoryContext);
-		MemoryStatsDsaArea = dsa_attach(memCxtArea->memstats_dsa_handle);
-		MemoryContextSwitchTo(oldcontext);
-		dsa_pin_mapping(MemoryStatsDsaArea);
-	}
-	LWLockRelease(&memCxtArea->lw_lock);
-
-	/*
-	 * Hold the process lock to protect writes to process specific memory. Two
-	 * processes publishing statistics do not block each other.
-	 */
-	LWLockAcquire(&memCxtState[idx].lw_lock, LW_EXCLUSIVE);
-	memCxtState[idx].proc_id = MyProcPid;
-
-	if (DsaPointerIsValid(memCxtState[idx].memstats_dsa_pointer))
-	{
-		/*
-		 * Free any previous allocations, free the name, ident and path
-		 * pointers before freeing the pointer that contains them.
-		 */
-		free_memorycontextstate_dsa(MemoryStatsDsaArea, memCxtState[idx].total_stats,
-									memCxtState[idx].memstats_dsa_pointer);
-	}
-
-	/*
-	 * Assigning total stats before allocating memory so that memory cleanup
-	 * can run if any subsequent dsa_allocate call to allocate name/ident/path
-	 * fails.
-	 */
-	memCxtState[idx].total_stats = stats_num;
-	memCxtState[idx].memstats_dsa_pointer =
-		dsa_allocate0(MemoryStatsDsaArea, stats_num * sizeof(MemoryStatsEntry));
-
-	meminfo = (MemoryStatsEntry *)
-		dsa_get_address(MemoryStatsDsaArea, memCxtState[idx].memstats_dsa_pointer);
-
-	if (summary)
-	{
-		int			cxt_id = 0;
-		List	   *path = NIL;
-
-		/* Copy TopMemoryContext statistics to DSA */
-		memset(&stat, 0, sizeof(stat));
-		(*TopMemoryContext->methods->stats) (TopMemoryContext, NULL, NULL,
-											 &stat, true);
-		path = lcons_int(1, path);
-		PublishMemoryContext(meminfo, cxt_id, TopMemoryContext, path, stat,
-							 1, MemoryStatsDsaArea, 100);
-		cxt_id = cxt_id + 1;
-
-		/*
-		 * Copy statistics for each of TopMemoryContexts children.  This
-		 * includes statistics of at most 100 children per node, with each
-		 * child node limited to a depth of 100 in its subtree.
-		 */
-		for (MemoryContext c = TopMemoryContext->firstchild; c != NULL;
-			 c = c->nextchild)
-		{
-			MemoryContextCounters grand_totals;
-			int			num_contexts = 0;
-
-			path = NIL;
-			memset(&grand_totals, 0, sizeof(grand_totals));
-
-			MemoryContextStatsInternal(c, 1, 100, 100, &grand_totals,
-									   PRINT_STATS_NONE, &num_contexts);
-
-			path = compute_context_path(c, context_id_lookup);
-
-			/*
-			 * Register the stats entry first, that way the cleanup handler
-			 * can reach it in case of allocation failures of one or more
-			 * members.
-			 */
-			memCxtState[idx].total_stats = cxt_id++;
-			PublishMemoryContext(meminfo, cxt_id, c, path,
-								 grand_totals, num_contexts, MemoryStatsDsaArea, 100);
-		}
-		memCxtState[idx].total_stats = cxt_id;
-
-		/* Notify waiting backends and return */
-		end_memorycontext_reporting();
-
-		hash_destroy(context_id_lookup);
-
-		return;
-	}
-
-	foreach_ptr(MemoryContextData, cur, contexts)
-	{
-		List	   *path = NIL;
-
-		/*
-		 * Figure out the transient context_id of this context and each of its
-		 * ancestors, to compute a path for this context.
-		 */
-		path = compute_context_path(cur, context_id_lookup);
-
-		/* Examine the context stats */
-		memset(&stat, 0, sizeof(stat));
-		(*cur->methods->stats) (cur, NULL, NULL, &stat, true);
-
-		/* Account for saving one statistics slot for cumulative reporting */
-		if (context_id < (max_stats - 1) || stats_count <= max_stats)
-		{
-			/* Copy statistics to DSA memory */
-			PublishMemoryContext(meminfo, context_id, cur, path, stat, 1, MemoryStatsDsaArea, 100);
-		}
-		else
-		{
-			meminfo[max_stats - 1].totalspace += stat.totalspace;
-			meminfo[max_stats - 1].nblocks += stat.nblocks;
-			meminfo[max_stats - 1].freespace += stat.freespace;
-			meminfo[max_stats - 1].freechunks += stat.freechunks;
-		}
-
-		/*
-		 * DSA max limit per process is reached, write aggregate of the
-		 * remaining statistics.
-		 *
-		 * We can store contexts from 0 to max_stats - 1. When stats_count is
-		 * greater than max_stats, we stop reporting individual statistics
-		 * when context_id equals max_stats - 2. As we use max_stats - 1 array
-		 * slot for reporting cumulative statistics or "Remaining Totals".
-		 */
-		if (stats_count > max_stats && context_id == (max_stats - 2))
-		{
-			char	   *nameptr;
-			int			namelen = strlen("Remaining Totals");
-
-			num_individual_stats = context_id + 1;
-			meminfo[max_stats - 1].name = dsa_allocate(MemoryStatsDsaArea, namelen + 1);
-			nameptr = dsa_get_address(MemoryStatsDsaArea, meminfo[max_stats - 1].name);
-			strlcpy(nameptr, "Remaining Totals", namelen + 1);
-			meminfo[max_stats - 1].ident = InvalidDsaPointer;
-			meminfo[max_stats - 1].path = InvalidDsaPointer;
-			meminfo[max_stats - 1].type = 0;
-		}
-		context_id++;
-	}
-
-	/*
-	 * Statistics are not aggregated, i.e individual statistics reported when
-	 * stats_count <= max_stats.
-	 */
-	if (stats_count <= max_stats)
-	{
-		memCxtState[idx].total_stats = context_id;
-	}
-	/* Report number of aggregated memory contexts */
-	else
-	{
-		meminfo[max_stats - 1].num_agg_stats = context_id -
-			num_individual_stats;
-
-		/*
-		 * Total stats equals num_individual_stats + 1 record for cumulative
-		 * statistics.
-		 */
-		memCxtState[idx].total_stats = num_individual_stats + 1;
-	}
-
-	/* Notify waiting backends and return */
-	end_memorycontext_reporting();
-
-	hash_destroy(context_id_lookup);
-}
-
-/*
- * Update timestamp and signal all the waiting client backends after copying
- * all the statistics.
- */
-static void
-end_memorycontext_reporting(void)
-{
-	memCxtState[MyProcNumber].stats_timestamp = GetCurrentTimestamp();
-	LWLockRelease(&memCxtState[MyProcNumber].lw_lock);
-	ConditionVariableBroadcast(&memCxtState[MyProcNumber].memcxt_cv);
-}
-
-/*
- * compute_context_path
- *
- * Append the transient context_id of this context and each of its ancestors
- * to a list, in order to compute a path.
- */
-static List *
-compute_context_path(MemoryContext c, HTAB *context_id_lookup)
-{
-	bool		found;
-	List	   *path = NIL;
-	MemoryContext cur_context;
-
-	for (cur_context = c; cur_context != NULL; cur_context = cur_context->parent)
-	{
-		MemoryStatsContextId *cur_entry;
-
-		cur_entry = hash_search(context_id_lookup, &cur_context, HASH_FIND, &found);
-
-		if (!found)
-			elog(ERROR, "hash table corrupted, can't construct path value");
-
-		path = lcons_int(cur_entry->context_id, path);
-	}
-
-	return path;
-}
-
-/*
- * Return the number of contexts allocated currently by the backend
- * Assign context ids to each of the contexts.
- */
-static void
-compute_contexts_count_and_ids(List *contexts, HTAB *context_id_lookup,
-							   int *stats_count, bool summary)
-{
-	foreach_ptr(MemoryContextData, cur, contexts)
-	{
-		MemoryStatsContextId *entry;
-		bool		found;
-
-		entry = (MemoryStatsContextId *) hash_search(context_id_lookup, &cur,
-													 HASH_ENTER, &found);
-		Assert(!found);
-
-		/*
-		 * context id starts with 1 so increment the stats_count before
-		 * assigning.
-		 */
-		entry->context_id = ++(*stats_count);
-
-		/* Append the children of the current context to the main list. */
-		for (MemoryContext c = cur->firstchild; c != NULL; c = c->nextchild)
-		{
-			if (summary)
-			{
-				entry = (MemoryStatsContextId *) hash_search(context_id_lookup, &c,
-															 HASH_ENTER, &found);
-				Assert(!found);
-
-				entry->context_id = ++(*stats_count);
-			}
-
-			contexts = lappend(contexts, c);
-		}
-
-		/*
-		 * In summary mode only the first two level (from top) contexts are
-		 * displayed.
-		 */
-		if (summary)
-			break;
-	}
-}
-
-/*
- * PublishMemoryContext
- *
- * Copy the memory context statistics of a single context to a DSA memory
- */
-static void
-PublishMemoryContext(MemoryStatsEntry *memcxt_info, int curr_id,
-					 MemoryContext context, List *path,
-					 MemoryContextCounters stat, int num_contexts,
-					 dsa_area *area, int max_levels)
-{
-	const char *ident = context->ident;
-	const char *name = context->name;
-	int		   *path_list;
-
-	/*
-	 * To be consistent with logging output, we label dynahash contexts with
-	 * just the hash table name as with MemoryContextStatsPrint().
-	 */
-	if (context->ident && strncmp(context->name, "dynahash", 8) == 0)
-	{
-		name = context->ident;
-		ident = NULL;
-	}
-
-	if (name != NULL)
-	{
-		int			namelen = strlen(name);
-		char	   *nameptr;
-
-		if (strlen(name) >= MEMORY_CONTEXT_IDENT_SHMEM_SIZE)
-			namelen = pg_mbcliplen(name, namelen,
-								   MEMORY_CONTEXT_IDENT_SHMEM_SIZE - 1);
-
-		memcxt_info[curr_id].name = dsa_allocate(area, namelen + 1);
-		nameptr = (char *) dsa_get_address(area, memcxt_info[curr_id].name);
-		strlcpy(nameptr, name, namelen + 1);
-	}
-	else
-		memcxt_info[curr_id].name = InvalidDsaPointer;
-
-	/* Trim and copy the identifier if it is not set to NULL */
-	if (ident != NULL)
-	{
-		int			idlen = strlen(context->ident);
-		char	   *identptr;
-
-		/*
-		 * Some identifiers such as SQL query string can be very long,
-		 * truncate oversize identifiers.
-		 */
-		if (idlen >= MEMORY_CONTEXT_IDENT_SHMEM_SIZE)
-			idlen = pg_mbcliplen(ident, idlen,
-								 MEMORY_CONTEXT_IDENT_SHMEM_SIZE - 1);
-
-		memcxt_info[curr_id].ident = dsa_allocate(area, idlen + 1);
-		identptr = (char *) dsa_get_address(area, memcxt_info[curr_id].ident);
-		strlcpy(identptr, ident, idlen + 1);
-	}
-	else
-		memcxt_info[curr_id].ident = InvalidDsaPointer;
-
-	/* Allocate DSA memory for storing path information */
-	if (path == NIL)
-		memcxt_info[curr_id].path = InvalidDsaPointer;
-	else
-	{
-		int			levels = Min(list_length(path), max_levels);
-
-		memcxt_info[curr_id].path_length = levels;
-		memcxt_info[curr_id].path = dsa_allocate0(area, levels * sizeof(int));
-		memcxt_info[curr_id].levels = list_length(path);
-		path_list = (int *) dsa_get_address(area, memcxt_info[curr_id].path);
-
-		foreach_int(i, path)
-		{
-			path_list[foreach_current_index(i)] = i;
-			if (--levels == 0)
-				break;
-		}
-	}
-	memcxt_info[curr_id].type = context->type;
-	memcxt_info[curr_id].totalspace = stat.totalspace;
-	memcxt_info[curr_id].nblocks = stat.nblocks;
-	memcxt_info[curr_id].freespace = stat.freespace;
-	memcxt_info[curr_id].freechunks = stat.freechunks;
-	memcxt_info[curr_id].num_agg_stats = num_contexts;
-}
-
-/*
- * free_memorycontextstate_dsa
- *
- * Worker for freeing resources from a MemoryStatsEntry.  Callers are
- * responsible for ensuring that the DSA pointer is valid.
- */
-static void
-free_memorycontextstate_dsa(dsa_area *area, int total_stats,
-							dsa_pointer prev_dsa_pointer)
-{
-	MemoryStatsEntry *meminfo;
-
-	meminfo = (MemoryStatsEntry *) dsa_get_address(area, prev_dsa_pointer);
-	Assert(meminfo != NULL);
-	for (int i = 0; i < total_stats; i++)
-	{
-		if (DsaPointerIsValid(meminfo[i].name))
-			dsa_free(area, meminfo[i].name);
-
-		if (DsaPointerIsValid(meminfo[i].ident))
-			dsa_free(area, meminfo[i].ident);
-
-		if (DsaPointerIsValid(meminfo[i].path))
-			dsa_free(area, meminfo[i].path);
-	}
-
-	dsa_free(area, memCxtState[MyProcNumber].memstats_dsa_pointer);
-	memCxtState[MyProcNumber].memstats_dsa_pointer = InvalidDsaPointer;
-}
-
-/*
- * Free the memory context statistics stored by this process
- * in DSA area.
- */
-void
-AtProcExit_memstats_cleanup(int code, Datum arg)
-{
-	int			idx = MyProcNumber;
-
-	if (memCxtArea->memstats_dsa_handle == DSA_HANDLE_INVALID)
-		return;
-
-	LWLockAcquire(&memCxtState[idx].lw_lock, LW_EXCLUSIVE);
-
-	if (!DsaPointerIsValid(memCxtState[idx].memstats_dsa_pointer))
-	{
-		LWLockRelease(&memCxtState[idx].lw_lock);
-		return;
-	}
-
-	/* If the dsa mapping could not be found, attach to the area */
-	if (MemoryStatsDsaArea == NULL)
-		MemoryStatsDsaArea = dsa_attach(memCxtArea->memstats_dsa_handle);
-
-	/*
-	 * Free the memory context statistics, free the name, ident and path
-	 * pointers before freeing the pointer that contains these pointers and
-	 * integer statistics.
-	 */
-	free_memorycontextstate_dsa(MemoryStatsDsaArea, memCxtState[idx].total_stats,
-								memCxtState[idx].memstats_dsa_pointer);
-
-	dsa_detach(MemoryStatsDsaArea);
-	LWLockRelease(&memCxtState[idx].lw_lock);
-}
-
 void *
 palloc(Size size)
 {