42#if defined(_SC_PAGE_SIZE)
43#define MHD_SC_PAGESIZE _SC_PAGE_SIZE
44#elif defined(_SC_PAGESIZE)
45#define MHD_SC_PAGESIZE _SC_PAGESIZE
50#if defined(MHD_USE_PAGESIZE_MACRO) || defined(MHD_USE_PAGE_SIZE_MACRO)
54#ifdef HAVE_SYS_PARAM_H
62#define _MHD_FALLBACK_PAGE_SIZE (4096)
64#if defined(MHD_USE_PAGESIZE_MACRO)
65#define MHD_DEF_PAGE_SIZE_ PAGESIZE
66#elif defined(MHD_USE_PAGE_SIZE_MACRO)
67#define MHD_DEF_PAGE_SIZE_ PAGE_SIZE
69#define MHD_DEF_PAGE_SIZE_ _MHD_FALLBACK_PAGE_SIZE
73#ifdef MHD_ASAN_POISON_ACTIVE
74#include <sanitizer/asan_interface.h>
78#if defined(MAP_ANON) && ! defined(MAP_ANONYMOUS)
79#define MAP_ANONYMOUS MAP_ANON
82#define MAP_FAILED NULL
83#elif ! defined(MAP_FAILED)
84#define MAP_FAILED ((void*) -1)
90#define ALIGN_SIZE (2 * sizeof(void*))
95#define ROUND_TO_ALIGN(n) (((n) + (ALIGN_SIZE - 1)) \
96 / (ALIGN_SIZE) *(ALIGN_SIZE))
99#ifndef MHD_ASAN_POISON_ACTIVE
100#define _MHD_NOSANITIZE_PTRS
101#define _MHD_RED_ZONE_SIZE (0)
102#define ROUND_TO_ALIGN_PLUS_RED_ZONE(n) ROUND_TO_ALIGN(n)
103#define _MHD_POISON_MEMORY(pointer, size) (void)0
104#define _MHD_UNPOISON_MEMORY(pointer, size) (void)0
106#if defined(FUNC_ATTR_PTRCOMPARE_WOKRS)
107#define _MHD_NOSANITIZE_PTRS \
108 __attribute__((no_sanitize("pointer-compare","pointer-subtract")))
109#elif defined(FUNC_ATTR_NOSANITIZE_WORKS)
110#define _MHD_NOSANITIZE_PTRS __attribute__((no_sanitize("address")))
112#define _MHD_RED_ZONE_SIZE (ALIGN_SIZE)
113#define ROUND_TO_ALIGN_PLUS_RED_ZONE(n) (ROUND_TO_ALIGN(n) + _MHD_RED_ZONE_SIZE)
114#define _MHD_POISON_MEMORY(pointer, size) \
115 ASAN_POISON_MEMORY_REGION ((pointer), (size))
116#define _MHD_UNPOISON_MEMORY(pointer, size) \
117 ASAN_UNPOISON_MEMORY_REGION ((pointer), (size))
124#if defined(MHD_USE_PAGESIZE_MACRO_STATIC)
126#elif defined(MHD_USE_PAGE_SIZE_MACRO_STATIC)
138#ifdef MHD_SC_PAGESIZE
140 result = sysconf (MHD_SC_PAGESIZE);
199 struct MemoryPool *pool;
204 pool = malloc (
sizeof (
struct MemoryPool));
207#if defined(MAP_ANONYMOUS) || defined(_WIN32)
208 if ( (max <= 32 * 1024) ||
218#if defined(MAP_ANONYMOUS) && ! defined(_WIN32)
219 pool->memory = mmap (
NULL,
221 PROT_READ | PROT_WRITE,
222 MAP_PRIVATE | MAP_ANONYMOUS,
226 pool->memory = VirtualAlloc (
NULL,
228 MEM_COMMIT | MEM_RESERVE,
238 pool->memory = malloc (alloc_size);
239 if (
NULL == pool->memory)
244 pool->is_mmap =
false;
246#if defined(MAP_ANONYMOUS) || defined(_WIN32)
249 pool->is_mmap =
true;
254 pool->end = alloc_size;
255 pool->size = alloc_size;
274 mhd_assert (pool->size >= pool->end - pool->pos);
279#if defined(MAP_ANONYMOUS) && ! defined(_WIN32)
280 munmap (pool->memory,
283 VirtualFree (pool->memory,
303 mhd_assert (pool->size >= pool->end - pool->pos);
304#ifdef MHD_ASAN_POISON_ACTIVE
332 mhd_assert (pool->size >= pool->end - pool->pos);
334 if ( (0 == asize) && (0 != size) )
336 if (asize > pool->end - pool->pos)
340 ret = &pool->memory[pool->end - asize];
345 ret = &pool->memory[pool->pos];
375 size_t *required_bytes)
381 mhd_assert (pool->size >= pool->end - pool->pos);
383 if ( (0 == asize) && (0 != size) )
388 if (asize > pool->end - pool->pos)
392 if (asize <= pool->end)
393 *required_bytes = asize - (pool->end - pool->pos);
398 ret = &pool->memory[pool->end - asize];
432 mhd_assert (pool->size >= pool->end - pool->pos);
439 (((
size_t) (((uint8_t *) old) - pool->memory)) + old_size));
443 pool->pos > (
size_t) ((uint8_t *) old - pool->memory));
445 (
size_t) (((uint8_t *) old) - pool->memory) + old_size <= \
450 const size_t old_offset = (uint8_t *) old - pool->memory;
451 const bool shrinking = (old_size > new_size);
455 memset ((uint8_t *) old + new_size, 0, old_size - new_size);
461 const size_t new_apos =
465 if ( (new_apos > pool->end) ||
466 (new_apos < pool->pos) )
470 pool->pos = new_apos;
479 if ( ( (0 == asize) &&
481 (asize > pool->end - pool->pos) )
484 new_blc = pool->memory + pool->pos;
491 memcpy (new_blc, old, old_size);
493 memset (old, 0, old_size);
520 mhd_assert (pool->size >= pool->end - pool->pos);
528 ((
size_t) ((uint8_t *) keep - pool->memory)) + copy_bytes);
530 if ( (
NULL != keep) &&
531 (keep != pool->memory) )
534 memmove (pool->memory,
539 if (pool->size > copy_bytes)
543 to_zero = pool->size - copy_bytes;
549 uint8_t *recommit_addr;
552 recommit_addr = pool->memory + pool->size - to_recommit;
556 if (VirtualFree (recommit_addr,
560 to_zero -= to_recommit;
562 if (recommit_addr != VirtualAlloc (recommit_addr,
570 memset (&pool->memory[copy_bytes],
575 pool->end = pool->size;
577 pool->size - new_size);
void * MHD_pool_reallocate(struct MemoryPool *pool, void *old, size_t old_size, size_t new_size)
void MHD_pool_destroy(struct MemoryPool *pool)
size_t MHD_pool_get_free(struct MemoryPool *pool)
void * MHD_pool_reset(struct MemoryPool *pool, void *keep, size_t copy_bytes, size_t new_size)
struct MemoryPool * MHD_pool_create(size_t max)
void * MHD_pool_allocate(struct MemoryPool *pool, size_t size, int from_end)
#define ROUND_TO_ALIGN(n)
void MHD_init_mem_pools_(void)
#define MHD_DEF_PAGE_SIZE_
#define _MHD_NOSANITIZE_PTRS
#define _MHD_FALLBACK_PAGE_SIZE
void * MHD_pool_try_alloc(struct MemoryPool *pool, size_t size, size_t *required_bytes)
#define ROUND_TO_ALIGN_PLUS_RED_ZONE(n)
#define _MHD_UNPOISON_MEMORY(pointer, size)
static size_t MHD_sys_page_size_
#define _MHD_POISON_MEMORY(pointer, size)
#define _MHD_RED_ZONE_SIZE
memory pool; mostly used for efficient (de)allocation for each connection and bounding memory use for...
limits values definitions