PostgreSQL Source Code  git master
mcxt.c
Go to the documentation of this file.
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-2018, 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 
29 
30 /*****************************************************************************
31  * GLOBAL MEMORY *
32  *****************************************************************************/
33 
34 /*
35  * CurrentMemoryContext
36  * Default memory context for allocations.
37  */
39 
40 /*
41  * Standard top-level contexts. For a description of the purpose of each
42  * of these contexts, refer to src/backend/utils/mmgr/README
43  */
51 
52 /* This is a transient link to the active portal's memory context: */
54 
56 static void MemoryContextStatsInternal(MemoryContext context, int level,
57  bool print, int max_children,
58  MemoryContextCounters *totals);
59 static void MemoryContextStatsPrint(MemoryContext context, void *passthru,
60  const char *stats_string);
61 
62 /*
63  * You should not do memory allocations within a critical section, because
64  * an out-of-memory error will be escalated to a PANIC. To enforce that
65  * rule, the allocation functions Assert that.
66  */
67 #define AssertNotInCriticalSection(context) \
68  Assert(CritSectionCount == 0 || (context)->allowInCritSection)
69 
70 /*****************************************************************************
71  * EXPORTED ROUTINES *
72  *****************************************************************************/
73 
74 
75 /*
76  * MemoryContextInit
77  * Start up the memory-context subsystem.
78  *
79  * This must be called before creating contexts or allocating memory in
80  * contexts. TopMemoryContext and ErrorContext are initialized here;
81  * other contexts must be created afterwards.
82  *
83  * In normal multi-backend operation, this is called once during
84  * postmaster startup, and not at all by individual backend startup
85  * (since the backends inherit an already-initialized context subsystem
86  * by virtue of being forked off the postmaster). But in an EXEC_BACKEND
87  * build, each process must do this for itself.
88  *
89  * In a standalone backend this must be called during backend startup.
90  */
91 void
93 {
94  AssertState(TopMemoryContext == NULL);
95 
96  /*
97  * First, initialize TopMemoryContext, which is the parent of all others.
98  */
99  TopMemoryContext = AllocSetContextCreate((MemoryContext) NULL,
100  "TopMemoryContext",
102 
103  /*
104  * Not having any other place to point CurrentMemoryContext, make it point
105  * to TopMemoryContext. Caller should change this soon!
106  */
107  CurrentMemoryContext = TopMemoryContext;
108 
109  /*
110  * Initialize ErrorContext as an AllocSetContext with slow growth rate ---
111  * we don't really expect much to be allocated in it. More to the point,
112  * require it to contain at least 8K at all times. This is the only case
113  * where retained memory in a context is *essential* --- we want to be
114  * sure ErrorContext still has some memory even if we've run out
115  * elsewhere! Also, allow allocations in ErrorContext within a critical
116  * section. Otherwise a PANIC will cause an assertion failure in the error
117  * reporting code, before printing out the real cause of the failure.
118  *
119  * This should be the last step in this function, as elog.c assumes memory
120  * management works once ErrorContext is non-null.
121  */
122  ErrorContext = AllocSetContextCreateExtended(TopMemoryContext,
123  "ErrorContext",
124  8 * 1024,
125  8 * 1024,
126  8 * 1024);
127  MemoryContextAllowInCriticalSection(ErrorContext, true);
128 }
129 
130 /*
131  * MemoryContextReset
132  * Release all space allocated within a context and delete all its
133  * descendant contexts (but not the named context itself).
134  */
135 void
137 {
139 
140  /* save a function call in common case where there are no children */
141  if (context->firstchild != NULL)
143 
144  /* save a function call if no pallocs since startup or last reset */
145  if (!context->isReset)
146  MemoryContextResetOnly(context);
147 }
148 
149 /*
150  * MemoryContextResetOnly
151  * Release all space allocated within a context.
152  * Nothing is done to the context's descendant contexts.
153  */
154 void
156 {
158 
159  /* Nothing to do if no pallocs since startup or last reset */
160  if (!context->isReset)
161  {
163 
164  /*
165  * If context->ident points into the context's memory, it will become
166  * a dangling pointer. We could prevent that by setting it to NULL
167  * here, but that would break valid coding patterns that keep the
168  * ident elsewhere, e.g. in a parent context. Another idea is to use
169  * MemoryContextContains(), but we don't require ident strings to be
170  * in separately-palloc'd chunks, so that risks false positives. So
171  * for now we assume the programmer got it right.
172  */
173 
174  context->methods->reset(context);
175  context->isReset = true;
176  VALGRIND_DESTROY_MEMPOOL(context);
177  VALGRIND_CREATE_MEMPOOL(context, 0, false);
178  }
179 }
180 
181 /*
182  * MemoryContextResetChildren
183  * Release all space allocated within a context's descendants,
184  * but don't delete the contexts themselves. The named context
185  * itself is not touched.
186  */
187 void
189 {
190  MemoryContext child;
191 
193 
194  for (child = context->firstchild; child != NULL; child = child->nextchild)
195  {
197  MemoryContextResetOnly(child);
198  }
199 }
200 
201 /*
202  * MemoryContextDelete
203  * Delete a context and its descendants, and release all space
204  * allocated therein.
205  *
206  * The type-specific delete routine removes all storage for the context,
207  * but we have to recurse to handle the children.
208  * We must also delink the context from its parent, if it has one.
209  */
210 void
212 {
214  /* We had better not be deleting TopMemoryContext ... */
215  Assert(context != TopMemoryContext);
216  /* And not CurrentMemoryContext, either */
217  Assert(context != CurrentMemoryContext);
218 
219  /* save a function call in common case where there are no children */
220  if (context->firstchild != NULL)
222 
223  /*
224  * It's not entirely clear whether 'tis better to do this before or after
225  * delinking the context; but an error in a callback will likely result in
226  * leaking the whole context (if it's not a root context) if we do it
227  * after, so let's do it before.
228  */
230 
231  /*
232  * We delink the context from its parent before deleting it, so that if
233  * there's an error we won't have deleted/busted contexts still attached
234  * to the context tree. Better a leak than a crash.
235  */
236  MemoryContextSetParent(context, NULL);
237 
238  /*
239  * Also reset the context's ident pointer, in case it points into the
240  * context. This would only matter if someone tries to get stats on the
241  * (already unlinked) context, which is unlikely, but let's be safe.
242  */
243  context->ident = NULL;
244 
245  context->methods->delete_context(context);
246 
247  VALGRIND_DESTROY_MEMPOOL(context);
248 }
249 
250 /*
251  * MemoryContextDeleteChildren
252  * Delete all the descendants of the named context and release all
253  * space allocated therein. The named context itself is not touched.
254  */
255 void
257 {
259 
260  /*
261  * MemoryContextDelete will delink the child from me, so just iterate as
262  * long as there is a child.
263  */
264  while (context->firstchild != NULL)
266 }
267 
268 /*
269  * MemoryContextRegisterResetCallback
270  * Register a function to be called before next context reset/delete.
271  * Such callbacks will be called in reverse order of registration.
272  *
273  * The caller is responsible for allocating a MemoryContextCallback struct
274  * to hold the info about this callback request, and for filling in the
275  * "func" and "arg" fields in the struct to show what function to call with
276  * what argument. Typically the callback struct should be allocated within
277  * the specified context, since that means it will automatically be freed
278  * when no longer needed.
279  *
280  * There is no API for deregistering a callback once registered. If you
281  * want it to not do anything anymore, adjust the state pointed to by its
282  * "arg" to indicate that.
283  */
284 void
287 {
289 
290  /* Push onto head so this will be called before older registrants. */
291  cb->next = context->reset_cbs;
292  context->reset_cbs = cb;
293  /* Mark the context as non-reset (it probably is already). */
294  context->isReset = false;
295 }
296 
297 /*
298  * MemoryContextCallResetCallbacks
299  * Internal function to call all registered callbacks for context.
300  */
301 static void
303 {
305 
306  /*
307  * We pop each callback from the list before calling. That way, if an
308  * error occurs inside the callback, we won't try to call it a second time
309  * in the likely event that we reset or delete the context later.
310  */
311  while ((cb = context->reset_cbs) != NULL)
312  {
313  context->reset_cbs = cb->next;
314  cb->func(cb->arg);
315  }
316 }
317 
318 /*
319  * MemoryContextSetIdentifier
320  * Set the identifier string for a memory context.
321  *
322  * An identifier can be provided to help distinguish among different contexts
323  * of the same kind in memory context stats dumps. The identifier string
324  * must live at least as long as the context it is for; typically it is
325  * allocated inside that context, so that it automatically goes away on
326  * context deletion. Pass id = NULL to forget any old identifier.
327  */
328 void
330 {
332  context->ident = id;
333 }
334 
335 /*
336  * MemoryContextSetParent
337  * Change a context to belong to a new parent (or no parent).
338  *
339  * We provide this as an API function because it is sometimes useful to
340  * change a context's lifespan after creation. For example, a context
341  * might be created underneath a transient context, filled with data,
342  * and then reparented underneath CacheMemoryContext to make it long-lived.
343  * In this way no special effort is needed to get rid of the context in case
344  * a failure occurs before its contents are completely set up.
345  *
346  * Callers often assume that this function cannot fail, so don't put any
347  * elog(ERROR) calls in it.
348  *
349  * A possible caller error is to reparent a context under itself, creating
350  * a loop in the context graph. We assert here that context != new_parent,
351  * but checking for multi-level loops seems more trouble than it's worth.
352  */
353 void
355 {
357  AssertArg(context != new_parent);
358 
359  /* Fast path if it's got correct parent already */
360  if (new_parent == context->parent)
361  return;
362 
363  /* Delink from existing parent, if any */
364  if (context->parent)
365  {
366  MemoryContext parent = context->parent;
367 
368  if (context->prevchild != NULL)
369  context->prevchild->nextchild = context->nextchild;
370  else
371  {
372  Assert(parent->firstchild == context);
373  parent->firstchild = context->nextchild;
374  }
375 
376  if (context->nextchild != NULL)
377  context->nextchild->prevchild = context->prevchild;
378  }
379 
380  /* And relink */
381  if (new_parent)
382  {
383  AssertArg(MemoryContextIsValid(new_parent));
384  context->parent = new_parent;
385  context->prevchild = NULL;
386  context->nextchild = new_parent->firstchild;
387  if (new_parent->firstchild != NULL)
388  new_parent->firstchild->prevchild = context;
389  new_parent->firstchild = context;
390  }
391  else
392  {
393  context->parent = NULL;
394  context->prevchild = NULL;
395  context->nextchild = NULL;
396  }
397 }
398 
399 /*
400  * MemoryContextAllowInCriticalSection
401  * Allow/disallow allocations in this memory context within a critical
402  * section.
403  *
404  * Normally, memory allocations are not allowed within a critical section,
405  * because a failure would lead to PANIC. There are a few exceptions to
406  * that, like allocations related to debugging code that is not supposed to
407  * be enabled in production. This function can be used to exempt specific
408  * memory contexts from the assertion in palloc().
409  */
410 void
412 {
414 
415  context->allowInCritSection = allow;
416 }
417 
418 /*
419  * GetMemoryChunkSpace
420  * Given a currently-allocated chunk, determine the total space
421  * it occupies (including all memory-allocation overhead).
422  *
423  * This is useful for measuring the total space occupied by a set of
424  * allocated chunks.
425  */
426 Size
427 GetMemoryChunkSpace(void *pointer)
428 {
429  MemoryContext context = GetMemoryChunkContext(pointer);
430 
431  return context->methods->get_chunk_space(context, pointer);
432 }
433 
434 /*
435  * MemoryContextGetParent
436  * Get the parent context (if any) of the specified context
437  */
440 {
442 
443  return context->parent;
444 }
445 
446 /*
447  * MemoryContextIsEmpty
448  * Is a memory context empty of any allocated space?
449  */
450 bool
452 {
454 
455  /*
456  * For now, we consider a memory context nonempty if it has any children;
457  * perhaps this should be changed later.
458  */
459  if (context->firstchild != NULL)
460  return false;
461  /* Otherwise use the type-specific inquiry */
462  return context->methods->is_empty(context);
463 }
464 
465 /*
466  * MemoryContextStats
467  * Print statistics about the named context and all its descendants.
468  *
469  * This is just a debugging utility, so it's not very fancy. However, we do
470  * make some effort to summarize when the output would otherwise be very long.
471  * The statistics are sent to stderr.
472  */
473 void
475 {
476  /* A hard-wired limit on the number of children is usually good enough */
477  MemoryContextStatsDetail(context, 100);
478 }
479 
480 /*
481  * MemoryContextStatsDetail
482  *
483  * Entry point for use if you want to vary the number of child contexts shown.
484  */
485 void
486 MemoryContextStatsDetail(MemoryContext context, int max_children)
487 {
488  MemoryContextCounters grand_totals;
489 
490  memset(&grand_totals, 0, sizeof(grand_totals));
491 
492  MemoryContextStatsInternal(context, 0, true, max_children, &grand_totals);
493 
494  fprintf(stderr,
495  "Grand total: %zu bytes in %zd blocks; %zu free (%zd chunks); %zu used\n",
496  grand_totals.totalspace, grand_totals.nblocks,
497  grand_totals.freespace, grand_totals.freechunks,
498  grand_totals.totalspace - grand_totals.freespace);
499 }
500 
501 /*
502  * MemoryContextStatsInternal
503  * One recursion level for MemoryContextStats
504  *
505  * Print this context if print is true, but in any case accumulate counts into
506  * *totals (if given).
507  */
508 static void
510  bool print, int max_children,
511  MemoryContextCounters *totals)
512 {
513  MemoryContextCounters local_totals;
514  MemoryContext child;
515  int ichild;
516 
518 
519  /* Examine the context itself */
520  context->methods->stats(context,
521  print ? MemoryContextStatsPrint : NULL,
522  (void *) &level,
523  totals);
524 
525  /*
526  * Examine children. If there are more than max_children of them, we do
527  * not print the rest explicitly, but just summarize them.
528  */
529  memset(&local_totals, 0, sizeof(local_totals));
530 
531  for (child = context->firstchild, ichild = 0;
532  child != NULL;
533  child = child->nextchild, ichild++)
534  {
535  if (ichild < max_children)
536  MemoryContextStatsInternal(child, level + 1,
537  print, max_children,
538  totals);
539  else
540  MemoryContextStatsInternal(child, level + 1,
541  false, max_children,
542  &local_totals);
543  }
544 
545  /* Deal with excess children */
546  if (ichild > max_children)
547  {
548  if (print)
549  {
550  int i;
551 
552  for (i = 0; i <= level; i++)
553  fprintf(stderr, " ");
554  fprintf(stderr,
555  "%d more child contexts containing %zu total in %zd blocks; %zu free (%zd chunks); %zu used\n",
556  ichild - max_children,
557  local_totals.totalspace,
558  local_totals.nblocks,
559  local_totals.freespace,
560  local_totals.freechunks,
561  local_totals.totalspace - local_totals.freespace);
562  }
563 
564  if (totals)
565  {
566  totals->nblocks += local_totals.nblocks;
567  totals->freechunks += local_totals.freechunks;
568  totals->totalspace += local_totals.totalspace;
569  totals->freespace += local_totals.freespace;
570  }
571  }
572 }
573 
574 /*
575  * MemoryContextStatsPrint
576  * Print callback used by MemoryContextStatsInternal
577  *
578  * For now, the passthru pointer just points to "int level"; later we might
579  * make that more complicated.
580  */
581 static void
582 MemoryContextStatsPrint(MemoryContext context, void *passthru,
583  const char *stats_string)
584 {
585  int level = *(int *) passthru;
586  const char *name = context->name;
587  const char *ident = context->ident;
588  int i;
589 
590  /*
591  * It seems preferable to label dynahash contexts with just the hash table
592  * name. Those are already unique enough, so the "dynahash" part isn't
593  * very helpful, and this way is more consistent with pre-v11 practice.
594  */
595  if (ident && strcmp(name, "dynahash") == 0)
596  {
597  name = ident;
598  ident = NULL;
599  }
600 
601  for (i = 0; i < level; i++)
602  fprintf(stderr, " ");
603  fprintf(stderr, "%s: %s", name, stats_string);
604  if (ident)
605  {
606  /*
607  * Some contexts may have very long identifiers (e.g., SQL queries).
608  * Arbitrarily truncate at 100 bytes, but be careful not to break
609  * multibyte characters. Also, replace ASCII control characters, such
610  * as newlines, with spaces.
611  */
612  int idlen = strlen(ident);
613  bool truncated = false;
614 
615  if (idlen > 100)
616  {
617  idlen = pg_mbcliplen(ident, idlen, 100);
618  truncated = true;
619  }
620  fprintf(stderr, ": ");
621  while (idlen-- > 0)
622  {
623  unsigned char c = *ident++;
624 
625  if (c < ' ')
626  c = ' ';
627  fputc(c, stderr);
628  }
629  if (truncated)
630  fprintf(stderr, "...");
631  }
632  fputc('\n', stderr);
633 }
634 
635 /*
636  * MemoryContextCheck
637  * Check all chunks in the named context.
638  *
639  * This is just a debugging utility, so it's not fancy.
640  */
641 #ifdef MEMORY_CONTEXT_CHECKING
642 void
643 MemoryContextCheck(MemoryContext context)
644 {
645  MemoryContext child;
646 
648 
649  context->methods->check(context);
650  for (child = context->firstchild; child != NULL; child = child->nextchild)
651  MemoryContextCheck(child);
652 }
653 #endif
654 
655 /*
656  * MemoryContextContains
657  * Detect whether an allocated chunk of memory belongs to a given
658  * context or not.
659  *
660  * Caution: this test is reliable as long as 'pointer' does point to
661  * a chunk of memory allocated from *some* context. If 'pointer' points
662  * at memory obtained in some other way, there is a small chance of a
663  * false-positive result, since the bits right before it might look like
664  * a valid chunk header by chance.
665  */
666 bool
667 MemoryContextContains(MemoryContext context, void *pointer)
668 {
669  MemoryContext ptr_context;
670 
671  /*
672  * NB: Can't use GetMemoryChunkContext() here - that performs assertions
673  * that aren't acceptable here since we might be passed memory not
674  * allocated by any memory context.
675  *
676  * Try to detect bogus pointers handed to us, poorly though we can.
677  * Presumably, a pointer that isn't MAXALIGNED isn't pointing at an
678  * allocated chunk.
679  */
680  if (pointer == NULL || pointer != (void *) MAXALIGN(pointer))
681  return false;
682 
683  /*
684  * OK, it's probably safe to look at the context.
685  */
686  ptr_context = *(MemoryContext *) (((char *) pointer) - sizeof(void *));
687 
688  return ptr_context == context;
689 }
690 
691 /*
692  * MemoryContextCreate
693  * Context-type-independent part of context creation.
694  *
695  * This is only intended to be called by context-type-specific
696  * context creation routines, not by the unwashed masses.
697  *
698  * The memory context creation procedure goes like this:
699  * 1. Context-type-specific routine makes some initial space allocation,
700  * including enough space for the context header. If it fails,
701  * it can ereport() with no damage done.
702  * 2. Context-type-specific routine sets up all type-specific fields of
703  * the header (those beyond MemoryContextData proper), as well as any
704  * other management fields it needs to have a fully valid context.
705  * Usually, failure in this step is impossible, but if it's possible
706  * the initial space allocation should be freed before ereport'ing.
707  * 3. Context-type-specific routine calls MemoryContextCreate() to fill in
708  * the generic header fields and link the context into the context tree.
709  * 4. We return to the context-type-specific routine, which finishes
710  * up type-specific initialization. This routine can now do things
711  * that might fail (like allocate more memory), so long as it's
712  * sure the node is left in a state that delete will handle.
713  *
714  * node: the as-yet-uninitialized common part of the context header node.
715  * tag: NodeTag code identifying the memory context type.
716  * methods: context-type-specific methods (usually statically allocated).
717  * parent: parent context, or NULL if this will be a top-level context.
718  * name: name of context (must be statically allocated).
719  *
720  * Context routines generally assume that MemoryContextCreate can't fail,
721  * so this can contain Assert but not elog/ereport.
722  */
723 void
725  NodeTag tag,
726  const MemoryContextMethods *methods,
727  MemoryContext parent,
728  const char *name)
729 {
730  /* Creating new memory contexts is not allowed in a critical section */
731  Assert(CritSectionCount == 0);
732 
733  /* Initialize all standard fields of memory context header */
734  node->type = tag;
735  node->isReset = true;
736  node->methods = methods;
737  node->parent = parent;
738  node->firstchild = NULL;
739  node->prevchild = NULL;
740  node->name = name;
741  node->ident = NULL;
742  node->reset_cbs = NULL;
743 
744  /* OK to link node into context tree */
745  if (parent)
746  {
747  node->nextchild = parent->firstchild;
748  if (parent->firstchild != NULL)
749  parent->firstchild->prevchild = node;
750  parent->firstchild = node;
751  /* inherit allowInCritSection flag from parent */
752  node->allowInCritSection = parent->allowInCritSection;
753  }
754  else
755  {
756  node->nextchild = NULL;
757  node->allowInCritSection = false;
758  }
759 
760  VALGRIND_CREATE_MEMPOOL(node, 0, false);
761 }
762 
763 /*
764  * MemoryContextAlloc
765  * Allocate space within the specified context.
766  *
767  * This could be turned into a macro, but we'd have to import
768  * nodes/memnodes.h into postgres.h which seems a bad idea.
769  */
770 void *
772 {
773  void *ret;
774 
777 
778  if (!AllocSizeIsValid(size))
779  elog(ERROR, "invalid memory alloc request size %zu", size);
780 
781  context->isReset = false;
782 
783  ret = context->methods->alloc(context, size);
784  if (unlikely(ret == NULL))
785  {
786  MemoryContextStats(TopMemoryContext);
787 
788  /*
789  * Here, and elsewhere in this module, we show the target context's
790  * "name" but not its "ident" (if any) in user-visible error messages.
791  * The "ident" string might contain security-sensitive data, such as
792  * values in SQL commands.
793  */
794  ereport(ERROR,
795  (errcode(ERRCODE_OUT_OF_MEMORY),
796  errmsg("out of memory"),
797  errdetail("Failed on request of size %zu in memory context \"%s\".",
798  size, context->name)));
799  }
800 
801  VALGRIND_MEMPOOL_ALLOC(context, ret, size);
802 
803  return ret;
804 }
805 
806 /*
807  * MemoryContextAllocZero
808  * Like MemoryContextAlloc, but clears allocated memory
809  *
810  * We could just call MemoryContextAlloc then clear the memory, but this
811  * is a very common combination, so we provide the combined operation.
812  */
813 void *
815 {
816  void *ret;
817 
820 
821  if (!AllocSizeIsValid(size))
822  elog(ERROR, "invalid memory alloc request size %zu", size);
823 
824  context->isReset = false;
825 
826  ret = context->methods->alloc(context, size);
827  if (unlikely(ret == NULL))
828  {
829  MemoryContextStats(TopMemoryContext);
830  ereport(ERROR,
831  (errcode(ERRCODE_OUT_OF_MEMORY),
832  errmsg("out of memory"),
833  errdetail("Failed on request of size %zu in memory context \"%s\".",
834  size, context->name)));
835  }
836 
837  VALGRIND_MEMPOOL_ALLOC(context, ret, size);
838 
839  MemSetAligned(ret, 0, size);
840 
841  return ret;
842 }
843 
844 /*
845  * MemoryContextAllocZeroAligned
846  * MemoryContextAllocZero where length is suitable for MemSetLoop
847  *
848  * This might seem overly specialized, but it's not because newNode()
849  * is so often called with compile-time-constant sizes.
850  */
851 void *
853 {
854  void *ret;
855 
858 
859  if (!AllocSizeIsValid(size))
860  elog(ERROR, "invalid memory alloc request size %zu", size);
861 
862  context->isReset = false;
863 
864  ret = context->methods->alloc(context, size);
865  if (unlikely(ret == NULL))
866  {
867  MemoryContextStats(TopMemoryContext);
868  ereport(ERROR,
869  (errcode(ERRCODE_OUT_OF_MEMORY),
870  errmsg("out of memory"),
871  errdetail("Failed on request of size %zu in memory context \"%s\".",
872  size, context->name)));
873  }
874 
875  VALGRIND_MEMPOOL_ALLOC(context, ret, size);
876 
877  MemSetLoop(ret, 0, size);
878 
879  return ret;
880 }
881 
882 /*
883  * MemoryContextAllocExtended
884  * Allocate space within the specified context using the given flags.
885  */
886 void *
888 {
889  void *ret;
890 
893 
894  if (((flags & MCXT_ALLOC_HUGE) != 0 && !AllocHugeSizeIsValid(size)) ||
895  ((flags & MCXT_ALLOC_HUGE) == 0 && !AllocSizeIsValid(size)))
896  elog(ERROR, "invalid memory alloc request size %zu", size);
897 
898  context->isReset = false;
899 
900  ret = context->methods->alloc(context, size);
901  if (unlikely(ret == NULL))
902  {
903  if ((flags & MCXT_ALLOC_NO_OOM) == 0)
904  {
905  MemoryContextStats(TopMemoryContext);
906  ereport(ERROR,
907  (errcode(ERRCODE_OUT_OF_MEMORY),
908  errmsg("out of memory"),
909  errdetail("Failed on request of size %zu in memory context \"%s\".",
910  size, context->name)));
911  }
912  return NULL;
913  }
914 
915  VALGRIND_MEMPOOL_ALLOC(context, ret, size);
916 
917  if ((flags & MCXT_ALLOC_ZERO) != 0)
918  MemSetAligned(ret, 0, size);
919 
920  return ret;
921 }
922 
923 void *
925 {
926  /* duplicates MemoryContextAlloc to avoid increased overhead */
927  void *ret;
929 
932 
933  if (!AllocSizeIsValid(size))
934  elog(ERROR, "invalid memory alloc request size %zu", size);
935 
936  context->isReset = false;
937 
938  ret = context->methods->alloc(context, size);
939  if (unlikely(ret == NULL))
940  {
941  MemoryContextStats(TopMemoryContext);
942  ereport(ERROR,
943  (errcode(ERRCODE_OUT_OF_MEMORY),
944  errmsg("out of memory"),
945  errdetail("Failed on request of size %zu in memory context \"%s\".",
946  size, context->name)));
947  }
948 
949  VALGRIND_MEMPOOL_ALLOC(context, ret, size);
950 
951  return ret;
952 }
953 
954 void *
956 {
957  /* duplicates MemoryContextAllocZero to avoid increased overhead */
958  void *ret;
960 
963 
964  if (!AllocSizeIsValid(size))
965  elog(ERROR, "invalid memory alloc request size %zu", size);
966 
967  context->isReset = false;
968 
969  ret = context->methods->alloc(context, size);
970  if (unlikely(ret == NULL))
971  {
972  MemoryContextStats(TopMemoryContext);
973  ereport(ERROR,
974  (errcode(ERRCODE_OUT_OF_MEMORY),
975  errmsg("out of memory"),
976  errdetail("Failed on request of size %zu in memory context \"%s\".",
977  size, context->name)));
978  }
979 
980  VALGRIND_MEMPOOL_ALLOC(context, ret, size);
981 
982  MemSetAligned(ret, 0, size);
983 
984  return ret;
985 }
986 
987 void *
988 palloc_extended(Size size, int flags)
989 {
990  /* duplicates MemoryContextAllocExtended to avoid increased overhead */
991  void *ret;
993 
996 
997  if (((flags & MCXT_ALLOC_HUGE) != 0 && !AllocHugeSizeIsValid(size)) ||
998  ((flags & MCXT_ALLOC_HUGE) == 0 && !AllocSizeIsValid(size)))
999  elog(ERROR, "invalid memory alloc request size %zu", size);
1000 
1001  context->isReset = false;
1002 
1003  ret = context->methods->alloc(context, size);
1004  if (unlikely(ret == NULL))
1005  {
1006  if ((flags & MCXT_ALLOC_NO_OOM) == 0)
1007  {
1008  MemoryContextStats(TopMemoryContext);
1009  ereport(ERROR,
1010  (errcode(ERRCODE_OUT_OF_MEMORY),
1011  errmsg("out of memory"),
1012  errdetail("Failed on request of size %zu in memory context \"%s\".",
1013  size, context->name)));
1014  }
1015  return NULL;
1016  }
1017 
1018  VALGRIND_MEMPOOL_ALLOC(context, ret, size);
1019 
1020  if ((flags & MCXT_ALLOC_ZERO) != 0)
1021  MemSetAligned(ret, 0, size);
1022 
1023  return ret;
1024 }
1025 
1026 /*
1027  * pfree
1028  * Release an allocated chunk.
1029  */
1030 void
1031 pfree(void *pointer)
1032 {
1033  MemoryContext context = GetMemoryChunkContext(pointer);
1034 
1035  context->methods->free_p(context, pointer);
1036  VALGRIND_MEMPOOL_FREE(context, pointer);
1037 }
1038 
1039 /*
1040  * repalloc
1041  * Adjust the size of a previously allocated chunk.
1042  */
1043 void *
1044 repalloc(void *pointer, Size size)
1045 {
1046  MemoryContext context = GetMemoryChunkContext(pointer);
1047  void *ret;
1048 
1049  if (!AllocSizeIsValid(size))
1050  elog(ERROR, "invalid memory alloc request size %zu", size);
1051 
1052  AssertNotInCriticalSection(context);
1053 
1054  /* isReset must be false already */
1055  Assert(!context->isReset);
1056 
1057  ret = context->methods->realloc(context, pointer, size);
1058  if (unlikely(ret == NULL))
1059  {
1060  MemoryContextStats(TopMemoryContext);
1061  ereport(ERROR,
1062  (errcode(ERRCODE_OUT_OF_MEMORY),
1063  errmsg("out of memory"),
1064  errdetail("Failed on request of size %zu in memory context \"%s\".",
1065  size, context->name)));
1066  }
1067 
1068  VALGRIND_MEMPOOL_CHANGE(context, pointer, ret, size);
1069 
1070  return ret;
1071 }
1072 
1073 /*
1074  * MemoryContextAllocHuge
1075  * Allocate (possibly-expansive) space within the specified context.
1076  *
1077  * See considerations in comment at MaxAllocHugeSize.
1078  */
1079 void *
1081 {
1082  void *ret;
1083 
1084  AssertArg(MemoryContextIsValid(context));
1085  AssertNotInCriticalSection(context);
1086 
1087  if (!AllocHugeSizeIsValid(size))
1088  elog(ERROR, "invalid memory alloc request size %zu", size);
1089 
1090  context->isReset = false;
1091 
1092  ret = context->methods->alloc(context, size);
1093  if (unlikely(ret == NULL))
1094  {
1095  MemoryContextStats(TopMemoryContext);
1096  ereport(ERROR,
1097  (errcode(ERRCODE_OUT_OF_MEMORY),
1098  errmsg("out of memory"),
1099  errdetail("Failed on request of size %zu in memory context \"%s\".",
1100  size, context->name)));
1101  }
1102 
1103  VALGRIND_MEMPOOL_ALLOC(context, ret, size);
1104 
1105  return ret;
1106 }
1107 
1108 /*
1109  * repalloc_huge
1110  * Adjust the size of a previously allocated chunk, permitting a large
1111  * value. The previous allocation need not have been "huge".
1112  */
1113 void *
1114 repalloc_huge(void *pointer, Size size)
1115 {
1116  MemoryContext context = GetMemoryChunkContext(pointer);
1117  void *ret;
1118 
1119  if (!AllocHugeSizeIsValid(size))
1120  elog(ERROR, "invalid memory alloc request size %zu", size);
1121 
1122  AssertNotInCriticalSection(context);
1123 
1124  /* isReset must be false already */
1125  Assert(!context->isReset);
1126 
1127  ret = context->methods->realloc(context, pointer, size);
1128  if (unlikely(ret == NULL))
1129  {
1130  MemoryContextStats(TopMemoryContext);
1131  ereport(ERROR,
1132  (errcode(ERRCODE_OUT_OF_MEMORY),
1133  errmsg("out of memory"),
1134  errdetail("Failed on request of size %zu in memory context \"%s\".",
1135  size, context->name)));
1136  }
1137 
1138  VALGRIND_MEMPOOL_CHANGE(context, pointer, ret, size);
1139 
1140  return ret;
1141 }
1142 
1143 /*
1144  * MemoryContextStrdup
1145  * Like strdup(), but allocate from the specified context
1146  */
1147 char *
1148 MemoryContextStrdup(MemoryContext context, const char *string)
1149 {
1150  char *nstr;
1151  Size len = strlen(string) + 1;
1152 
1153  nstr = (char *) MemoryContextAlloc(context, len);
1154 
1155  memcpy(nstr, string, len);
1156 
1157  return nstr;
1158 }
1159 
1160 char *
1161 pstrdup(const char *in)
1162 {
1163  return MemoryContextStrdup(CurrentMemoryContext, in);
1164 }
1165 
1166 /*
1167  * pnstrdup
1168  * Like pstrdup(), but append null byte to a
1169  * not-necessarily-null-terminated input string.
1170  */
1171 char *
1172 pnstrdup(const char *in, Size len)
1173 {
1174  char *out;
1175 
1176  len = strnlen(in, len);
1177 
1178  out = palloc(len + 1);
1179  memcpy(out, in, len);
1180  out[len] = '\0';
1181 
1182  return out;
1183 }
1184 
1185 /*
1186  * Make copy of string with all trailing newline characters removed.
1187  */
1188 char *
1189 pchomp(const char *in)
1190 {
1191  size_t n;
1192 
1193  n = strlen(in);
1194  while (n > 0 && in[n - 1] == '\n')
1195  n--;
1196  return pnstrdup(in, n);
1197 }
#define MemSetAligned(start, val, len)
Definition: c.h:941
MemoryContextCallbackFunction func
Definition: palloc.h:49
Size(* get_chunk_space)(MemoryContext context, void *pointer)
Definition: memnodes.h:65
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:211
MemoryContext AllocSetContextCreateExtended(MemoryContext parent, const char *name, Size minContextSize, Size initBlockSize, Size maxBlockSize)
Definition: aset.c:388
char * pnstrdup(const char *in, Size len)
Definition: mcxt.c:1172
static void MemoryContextCallResetCallbacks(MemoryContext context)
Definition: mcxt.c:302
#define AssertState(condition)
Definition: c.h:702
MemoryContext TopTransactionContext
Definition: mcxt.c:49
MemoryContextCallback * reset_cbs
Definition: memnodes.h:89
void print(const void *obj)
Definition: print.c:35
void MemoryContextAllowInCriticalSection(MemoryContext context, bool allow)
Definition: mcxt.c:411
void MemoryContextInit(void)
Definition: mcxt.c:92
#define MCXT_ALLOC_HUGE
Definition: fe_memutils.h:16
const MemoryContextMethods * methods
Definition: memnodes.h:82
MemoryContext MemoryContextGetParent(MemoryContext context)
Definition: mcxt.c:439
MemoryContext ErrorContext
Definition: mcxt.c:45
void(* reset)(MemoryContext context)
Definition: memnodes.h:63
void * MemoryContextAllocExtended(MemoryContext context, Size size, int flags)
Definition: mcxt.c:887
void MemoryContextSetParent(MemoryContext context, MemoryContext new_parent)
Definition: mcxt.c:354
char * pstrdup(const char *in)
Definition: mcxt.c:1161
bool allowInCritSection
Definition: memnodes.h:81
static void MemoryContextStatsInternal(MemoryContext context, int level, bool print, int max_children, MemoryContextCounters *totals)
Definition: mcxt.c:509
MemoryContext CurTransactionContext
Definition: mcxt.c:50
void * palloc_extended(Size size, int flags)
Definition: mcxt.c:988
#define MCXT_ALLOC_NO_OOM
Definition: fe_memutils.h:18
int errcode(int sqlerrcode)
Definition: elog.c:575
Size GetMemoryChunkSpace(void *pointer)
Definition: mcxt.c:427
void MemoryContextReset(MemoryContext context)
Definition: mcxt.c:136
#define AssertNotInCriticalSection(context)
Definition: mcxt.c:67
NodeTag
Definition: nodes.h:26
void MemoryContextResetOnly(MemoryContext context)
Definition: mcxt.c:155
void(* stats)(MemoryContext context, MemoryStatsPrintFunc printfunc, void *passthru, MemoryContextCounters *totals)
Definition: memnodes.h:67
void *(* realloc)(MemoryContext context, void *pointer, Size size)
Definition: memnodes.h:62
MemoryContext PortalContext
Definition: mcxt.c:53
char * pchomp(const char *in)
Definition: mcxt.c:1189
MemoryContext firstchild
Definition: memnodes.h:84
void pfree(void *pointer)
Definition: mcxt.c:1031
void(* free_p)(MemoryContext context, void *pointer)
Definition: memnodes.h:61
#define ERROR
Definition: elog.h:43
bool MemoryContextIsEmpty(MemoryContext context)
Definition: mcxt.c:451
bool(* is_empty)(MemoryContext context)
Definition: memnodes.h:66
#define VALGRIND_MEMPOOL_CHANGE(context, optr, nptr, size)
Definition: memdebug.h:31
void MemoryContextStats(MemoryContext context)
Definition: mcxt.c:474
#define MemSetLoop(start, val, len)
Definition: c.h:976
int pg_mbcliplen(const char *mbstr, int len, int limit)
Definition: mbutils.c:820
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:192
char * c
void * MemoryContextAllocHuge(MemoryContext context, Size size)
Definition: mcxt.c:1080
#define VALGRIND_MEMPOOL_FREE(context, addr)
Definition: memdebug.h:30
int errdetail(const char *fmt,...)
Definition: elog.c:873
MemoryContext prevchild
Definition: memnodes.h:85
MemoryContext CurrentMemoryContext
Definition: mcxt.c:38
void *(* alloc)(MemoryContext context, Size size)
Definition: memnodes.h:59
volatile uint32 CritSectionCount
Definition: globals.c:38
void MemoryContextCreate(MemoryContext node, NodeTag tag, const MemoryContextMethods *methods, MemoryContext parent, const char *name)
Definition: mcxt.c:724
#define ereport(elevel, rest)
Definition: elog.h:122
#define AssertArg(condition)
Definition: c.h:701
void * MemoryContextAllocZeroAligned(MemoryContext context, Size size)
Definition: mcxt.c:852
const char * ident
Definition: memnodes.h:88
MemoryContext TopMemoryContext
Definition: mcxt.c:44
#define AllocSizeIsValid(size)
Definition: memutils.h:42
#define AllocSetContextCreate(parent, name, allocparams)
Definition: memutils.h:170
void MemoryContextDeleteChildren(MemoryContext context)
Definition: mcxt.c:256
#define VALGRIND_DESTROY_MEMPOOL(context)
Definition: memdebug.h:25
void * palloc0(Size size)
Definition: mcxt.c:955
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:814
#define VALGRIND_CREATE_MEMPOOL(context, redzones, zeroed)
Definition: memdebug.h:24
#define MemoryContextIsValid(context)
Definition: memnodes.h:101
#define VALGRIND_MEMPOOL_ALLOC(context, addr, size)
Definition: memdebug.h:29
#define Assert(condition)
Definition: c.h:699
void MemoryContextResetChildren(MemoryContext context)
Definition: mcxt.c:188
#define MCXT_ALLOC_ZERO
Definition: fe_memutils.h:19
bool MemoryContextContains(MemoryContext context, void *pointer)
Definition: mcxt.c:667
size_t Size
Definition: c.h:433
#define MAXALIGN(LEN)
Definition: c.h:652
void MemoryContextSetIdentifier(MemoryContext context, const char *id)
Definition: mcxt.c:329
static void MemoryContextStatsPrint(MemoryContext context, void *passthru, const char *stats_string)
Definition: mcxt.c:582
size_t strnlen(const char *str, size_t maxlen)
Definition: strnlen.c:26
MemoryContext MessageContext
Definition: mcxt.c:48
void * repalloc(void *pointer, Size size)
Definition: mcxt.c:1044
const char * name
Definition: encode.c:521
#define AllocHugeSizeIsValid(size)
Definition: memutils.h:46
void * repalloc_huge(void *pointer, Size size)
Definition: mcxt.c:1114
void * palloc(Size size)
Definition: mcxt.c:924
int errmsg(const char *fmt,...)
Definition: elog.c:797
char * MemoryContextStrdup(MemoryContext context, const char *string)
Definition: mcxt.c:1148
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:771
struct MemoryContextCallback * next
Definition: palloc.h:51
int i
MemoryContext parent
Definition: memnodes.h:83
#define unlikely(x)
Definition: c.h:208
void MemoryContextRegisterResetCallback(MemoryContext context, MemoryContextCallback *cb)
Definition: mcxt.c:285
void(* delete_context)(MemoryContext context)
Definition: memnodes.h:64
#define elog
Definition: elog.h:219
MemoryContext PostmasterContext
Definition: mcxt.c:46
const char * name
Definition: memnodes.h:87
MemoryContext nextchild
Definition: memnodes.h:86
void MemoryContextStatsDetail(MemoryContext context, int max_children)
Definition: mcxt.c:486
static MemoryContext GetMemoryChunkContext(void *pointer)
Definition: memutils.h:112
MemoryContext CacheMemoryContext
Definition: mcxt.c:47
NodeTag type
Definition: memnodes.h:78