Line data Source code
1 : /*------------------------------------------------------------------------- 2 : * 3 : * alignedalloc.c 4 : * Allocator functions to implement palloc_aligned 5 : * 6 : * This is not a fully-fledged MemoryContext type as there is no means to 7 : * create a MemoryContext of this type. The code here only serves to allow 8 : * operations such as pfree() and repalloc() to work correctly on a memory 9 : * chunk that was allocated by palloc_aligned(). 10 : * 11 : * Portions Copyright (c) 2022-2025, PostgreSQL Global Development Group 12 : * 13 : * IDENTIFICATION 14 : * src/backend/utils/mmgr/alignedalloc.c 15 : * 16 : *------------------------------------------------------------------------- 17 : */ 18 : 19 : #include "postgres.h" 20 : 21 : #include "utils/memdebug.h" 22 : #include "utils/memutils_memorychunk.h" 23 : 24 : /* 25 : * AlignedAllocFree 26 : * Frees allocated memory; memory is removed from its owning context. 27 : */ 28 : void 29 332024 : AlignedAllocFree(void *pointer) 30 : { 31 332024 : MemoryChunk *chunk = PointerGetMemoryChunk(pointer); 32 : void *unaligned; 33 : 34 : VALGRIND_MAKE_MEM_DEFINED(chunk, sizeof(MemoryChunk)); 35 : 36 : Assert(!MemoryChunkIsExternal(chunk)); 37 : 38 : /* obtain the original (unaligned) allocated pointer */ 39 332024 : unaligned = MemoryChunkGetBlock(chunk); 40 : 41 : #ifdef MEMORY_CONTEXT_CHECKING 42 : /* Test for someone scribbling on unused space in chunk */ 43 : if (!sentinel_ok(pointer, chunk->requested_size)) 44 : elog(WARNING, "detected write past chunk end in %s %p", 45 : GetMemoryChunkContext(unaligned)->name, chunk); 46 : #endif 47 : 48 : /* Recursively pfree the unaligned chunk */ 49 332024 : pfree(unaligned); 50 332024 : } 51 : 52 : /* 53 : * AlignedAllocRealloc 54 : * Change the allocated size of a chunk and return possibly a different 55 : * pointer to a memory address aligned to the same boundary as the 56 : * originally requested alignment. The contents of 'pointer' will be 57 : * copied into the returned pointer up until 'size'. Any additional 58 : * memory will be uninitialized. 59 : */ 60 : void * 61 0 : AlignedAllocRealloc(void *pointer, Size size, int flags) 62 : { 63 0 : MemoryChunk *redirchunk = PointerGetMemoryChunk(pointer); 64 : Size alignto; 65 : void *unaligned; 66 : MemoryContext ctx; 67 : Size old_size; 68 : void *newptr; 69 : 70 : VALGRIND_MAKE_MEM_DEFINED(redirchunk, sizeof(MemoryChunk)); 71 : 72 0 : alignto = MemoryChunkGetValue(redirchunk); 73 0 : unaligned = MemoryChunkGetBlock(redirchunk); 74 : 75 : /* sanity check this is a power of 2 value */ 76 : Assert((alignto & (alignto - 1)) == 0); 77 : 78 : /* 79 : * Determine the size of the original allocation. We can't determine this 80 : * exactly as GetMemoryChunkSpace() returns the total space used for the 81 : * allocation, which for contexts like aset includes rounding up to the 82 : * next power of 2. However, this value is just used to memcpy() the old 83 : * data into the new allocation, so we only need to concern ourselves with 84 : * not reading beyond the end of the original allocation's memory. The 85 : * drawback here is that we may copy more bytes than we need to, which 86 : * only amounts to wasted effort. We can safely subtract the extra bytes 87 : * that we requested to allow us to align the pointer. We must also 88 : * subtract the space for the unaligned pointer's MemoryChunk since 89 : * GetMemoryChunkSpace should have included that. This does assume that 90 : * all context types use MemoryChunk as a chunk header. 91 : */ 92 0 : old_size = GetMemoryChunkSpace(unaligned) - 93 : PallocAlignedExtraBytes(alignto) - sizeof(MemoryChunk); 94 : 95 : #ifdef MEMORY_CONTEXT_CHECKING 96 : /* check that GetMemoryChunkSpace returned something realistic */ 97 : Assert(old_size >= redirchunk->requested_size); 98 : #endif 99 : 100 : /* 101 : * To keep things simple, we always allocate a new aligned chunk and copy 102 : * data into it. Because of the above inaccuracy, this may end in copying 103 : * more data than was in the original allocation request size, but that 104 : * should be OK. 105 : */ 106 0 : ctx = GetMemoryChunkContext(unaligned); 107 0 : newptr = MemoryContextAllocAligned(ctx, size, alignto, flags); 108 : 109 : /* Cope cleanly with OOM */ 110 0 : if (unlikely(newptr == NULL)) 111 : { 112 : VALGRIND_MAKE_MEM_NOACCESS(redirchunk, sizeof(MemoryChunk)); 113 0 : return MemoryContextAllocationFailure(ctx, size, flags); 114 : } 115 : 116 : /* 117 : * We may memcpy more than the original allocation request size, which 118 : * would result in trying to copy trailing bytes that the original 119 : * MemoryContextAllocAligned call marked NOACCESS. So we must mark the 120 : * entire old_size as defined. That's slightly annoying, but probably not 121 : * worth improving. 122 : */ 123 : VALGRIND_MAKE_MEM_DEFINED(pointer, old_size); 124 0 : memcpy(newptr, pointer, Min(size, old_size)); 125 : 126 0 : pfree(unaligned); 127 : 128 0 : return newptr; 129 : } 130 : 131 : /* 132 : * AlignedAllocGetChunkContext 133 : * Return the MemoryContext that 'pointer' belongs to. 134 : */ 135 : MemoryContext 136 0 : AlignedAllocGetChunkContext(void *pointer) 137 : { 138 0 : MemoryChunk *redirchunk = PointerGetMemoryChunk(pointer); 139 : MemoryContext cxt; 140 : 141 : VALGRIND_MAKE_MEM_DEFINED(redirchunk, sizeof(MemoryChunk)); 142 : 143 : Assert(!MemoryChunkIsExternal(redirchunk)); 144 : 145 0 : cxt = GetMemoryChunkContext(MemoryChunkGetBlock(redirchunk)); 146 : 147 : VALGRIND_MAKE_MEM_NOACCESS(redirchunk, sizeof(MemoryChunk)); 148 : 149 0 : return cxt; 150 : } 151 : 152 : /* 153 : * AlignedAllocGetChunkSpace 154 : * Given a currently-allocated chunk, determine the total space 155 : * it occupies (including all memory-allocation overhead). 156 : */ 157 : Size 158 0 : AlignedAllocGetChunkSpace(void *pointer) 159 : { 160 0 : MemoryChunk *redirchunk = PointerGetMemoryChunk(pointer); 161 : void *unaligned; 162 : Size space; 163 : 164 : VALGRIND_MAKE_MEM_DEFINED(redirchunk, sizeof(MemoryChunk)); 165 : 166 0 : unaligned = MemoryChunkGetBlock(redirchunk); 167 0 : space = GetMemoryChunkSpace(unaligned); 168 : 169 : VALGRIND_MAKE_MEM_NOACCESS(redirchunk, sizeof(MemoryChunk)); 170 : 171 0 : return space; 172 : }