deps/jemalloc/src/chunk_dss.c

#define	JEMALLOC_CHUNK_DSS_C_
#include "jemalloc/internal/jemalloc_internal.h"
/******************************************************************************/
/* Data. */

/*
 * Protects sbrk() calls.  This avoids malloc races among threads, though it
 * does not protect against races with threads that call sbrk() directly.
 */
static malloc_mutex_t	dss_mtx;

/* Base address of the DSS. */
static void		*dss_base;
/* Current end of the DSS, or ((void *)-1) if the DSS is exhausted. */
static void		*dss_prev;
/* Current upper limit on DSS addresses. */
static void		*dss_max;

/******************************************************************************/

#ifndef JEMALLOC_HAVE_SBRK
static void *
sbrk(intptr_t increment)
{

	not_implemented();

	return (NULL);
}
#endif

void *
chunk_alloc_dss(size_t size, size_t alignment, bool *zero)
{
	void *ret;

	cassert(config_dss);
	assert(size > 0 && (size & chunksize_mask) == 0);
	assert(alignment > 0 && (alignment & chunksize_mask) == 0);

	/*
	 * sbrk() uses a signed increment argument, so take care not to
	 * interpret a huge allocation request as a negative increment.
	 */
	if ((intptr_t)size < 0)
		return (NULL);

	malloc_mutex_lock(&dss_mtx);
	if (dss_prev != (void *)-1) {
		size_t gap_size, cpad_size;
		void *cpad, *dss_next;
		intptr_t incr;

		/*
		 * The loop is necessary to recover from races with other
		 * threads that are using the DSS for something other than
		 * malloc.
		 */
		do {
			/* Get the current end of the DSS. */
			dss_max = sbrk(0);
			/*
			 * Calculate how much padding is necessary to
			 * chunk-align the end of the DSS.
			 */
			gap_size = (chunksize - CHUNK_ADDR2OFFSET(dss_max)) &
			    chunksize_mask;
			/*
			 * Compute how much chunk-aligned pad space (if any) is
			 * necessary to satisfy alignment.  This space can be
			 * recycled for later use.
			 */
			cpad = (void *)((uintptr_t)dss_max + gap_size);
			ret = (void *)ALIGNMENT_CEILING((uintptr_t)dss_max,
			    alignment);
			cpad_size = (uintptr_t)ret - (uintptr_t)cpad;
			dss_next = (void *)((uintptr_t)ret + size);
			if ((uintptr_t)ret < (uintptr_t)dss_max ||
			    (uintptr_t)dss_next < (uintptr_t)dss_max) {
				/* Wrap-around. */
				malloc_mutex_unlock(&dss_mtx);
				return (NULL);
			}
			incr = gap_size + cpad_size + size;
			dss_prev = sbrk(incr);
			if (dss_prev == dss_max) {
				/* Success. */
				dss_max = dss_next;
				malloc_mutex_unlock(&dss_mtx);
				if (cpad_size != 0)
					chunk_dealloc(cpad, cpad_size, true);
				if (*zero) {
					VALGRIND_MAKE_MEM_UNDEFINED(ret, size);
					memset(ret, 0, size);
				}
				return (ret);
			}
		} while (dss_prev != (void *)-1);
	}
	malloc_mutex_unlock(&dss_mtx);

	return (NULL);
}

bool
chunk_in_dss(void *chunk)
{
	bool ret;

	cassert(config_dss);

	malloc_mutex_lock(&dss_mtx);
	if ((uintptr_t)chunk >= (uintptr_t)dss_base
	    && (uintptr_t)chunk < (uintptr_t)dss_max)
		ret = true;
	else
		ret = false;
	malloc_mutex_unlock(&dss_mtx);

	return (ret);
}

bool
chunk_dss_boot(void)
{

	cassert(config_dss);

	if (malloc_mutex_init(&dss_mtx))
		return (true);
	dss_base = sbrk(0);
	dss_prev = dss_base;
	dss_max = dss_base;

	return (false);
}

void
chunk_dss_prefork(void)
{

	if (config_dss)
		malloc_mutex_prefork(&dss_mtx);
}

void
chunk_dss_postfork_parent(void)
{

	if (config_dss)
		malloc_mutex_postfork_parent(&dss_mtx);
}

void
chunk_dss_postfork_child(void)
{

	if (config_dss)
		malloc_mutex_postfork_child(&dss_mtx);
}

/******************************************************************************/
Commit	Line	Data
	1	#define JEMALLOC_CHUNK_DSS_C_
	2	#include "jemalloc/internal/jemalloc_internal.h"
	3	/******************************************************************************/
	4	/* Data. */
	5
	6	/*
	7	* Protects sbrk() calls. This avoids malloc races among threads, though it
	8	* does not protect against races with threads that call sbrk() directly.
	9	*/
	10	static malloc_mutex_t dss_mtx;
	11
	12	/* Base address of the DSS. */
	13	static void *dss_base;
	14	/* Current end of the DSS, or ((void )-1) if the DSS is exhausted. /
	15	static void *dss_prev;
	16	/* Current upper limit on DSS addresses. */
	17	static void *dss_max;
	18
	19	/******************************************************************************/
	20
	21	#ifndef JEMALLOC_HAVE_SBRK
	22	static void *
	23	sbrk(intptr_t increment)
	24	{
	25
	26	not_implemented();
	27
	28	return (NULL);
	29	}
	30	#endif
	31
	32	void *
	33	chunk_alloc_dss(size_t size, size_t alignment, bool *zero)
	34	{
	35	void *ret;
	36
	37	cassert(config_dss);
	38	assert(size > 0 && (size & chunksize_mask) == 0);
	39	assert(alignment > 0 && (alignment & chunksize_mask) == 0);
	40
	41	/*
	42	* sbrk() uses a signed increment argument, so take care not to
	43	* interpret a huge allocation request as a negative increment.
	44	*/
	45	if ((intptr_t)size < 0)
	46	return (NULL);
	47
	48	malloc_mutex_lock(&dss_mtx);
	49	if (dss_prev != (void *)-1) {
	50	size_t gap_size, cpad_size;
	51	void cpad, dss_next;
	52	intptr_t incr;
	53
	54	/*
	55	* The loop is necessary to recover from races with other
	56	* threads that are using the DSS for something other than
	57	* malloc.
	58	*/
	59	do {
	60	/* Get the current end of the DSS. */
	61	dss_max = sbrk(0);
	62	/*
	63	* Calculate how much padding is necessary to
	64	* chunk-align the end of the DSS.
	65	*/
	66	gap_size = (chunksize - CHUNK_ADDR2OFFSET(dss_max)) &
	67	chunksize_mask;
	68	/*
	69	* Compute how much chunk-aligned pad space (if any) is
	70	* necessary to satisfy alignment. This space can be
	71	* recycled for later use.
	72	*/
	73	cpad = (void *)((uintptr_t)dss_max + gap_size);
	74	ret = (void *)ALIGNMENT_CEILING((uintptr_t)dss_max,
	75	alignment);
	76	cpad_size = (uintptr_t)ret - (uintptr_t)cpad;
	77	dss_next = (void *)((uintptr_t)ret + size);
	78	if ((uintptr_t)ret < (uintptr_t)dss_max \|\|
	79	(uintptr_t)dss_next < (uintptr_t)dss_max) {
	80	/* Wrap-around. */
	81	malloc_mutex_unlock(&dss_mtx);
	82	return (NULL);
	83	}
	84	incr = gap_size + cpad_size + size;
	85	dss_prev = sbrk(incr);
	86	if (dss_prev == dss_max) {
	87	/* Success. */
	88	dss_max = dss_next;
	89	malloc_mutex_unlock(&dss_mtx);
	90	if (cpad_size != 0)
	91	chunk_dealloc(cpad, cpad_size, true);
	92	if (*zero) {
	93	VALGRIND_MAKE_MEM_UNDEFINED(ret, size);
	94	memset(ret, 0, size);
	95	}
	96	return (ret);
	97	}
	98	} while (dss_prev != (void *)-1);
	99	}
	100	malloc_mutex_unlock(&dss_mtx);
	101
	102	return (NULL);
	103	}
	104
	105	bool
	106	chunk_in_dss(void *chunk)
	107	{
	108	bool ret;
	109
	110	cassert(config_dss);
	111
	112	malloc_mutex_lock(&dss_mtx);
	113	if ((uintptr_t)chunk >= (uintptr_t)dss_base
	114	&& (uintptr_t)chunk < (uintptr_t)dss_max)
	115	ret = true;
	116	else
	117	ret = false;
	118	malloc_mutex_unlock(&dss_mtx);
	119
	120	return (ret);
	121	}
	122
	123	bool
	124	chunk_dss_boot(void)
	125	{
	126
	127	cassert(config_dss);
	128
	129	if (malloc_mutex_init(&dss_mtx))
	130	return (true);
	131	dss_base = sbrk(0);
	132	dss_prev = dss_base;
	133	dss_max = dss_base;
	134
	135	return (false);
	136	}
	137
	138	void
	139	chunk_dss_prefork(void)
	140	{
	141
	142	if (config_dss)
	143	malloc_mutex_prefork(&dss_mtx);
	144	}
	145
	146	void
	147	chunk_dss_postfork_parent(void)
	148	{
	149
	150	if (config_dss)
	151	malloc_mutex_postfork_parent(&dss_mtx);
	152	}
	153
	154	void
	155	chunk_dss_postfork_child(void)
	156	{
	157
	158	if (config_dss)
	159	malloc_mutex_postfork_child(&dss_mtx);
	160	}
	161
	162	/******************************************************************************/