Thanks to visit codestin.com
Credit goes to doxygen.postgresql.org

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