The Tor Browser: memory/jemalloc/src/src/base.c@b8a032363ba2

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

     1 #define	JEMALLOC_BASE_C_

     2 #include "jemalloc/internal/jemalloc_internal.h"

     4 /******************************************************************************/

     5 /* Data. */

     7 static malloc_mutex_t	base_mtx;

     9 /*

    10  * Current pages that are being used for internal memory allocations.  These

    11  * pages are carved up in cacheline-size quanta, so that there is no chance of

    12  * false cache line sharing.

    13  */

    14 static void		*base_pages;

    15 static void		*base_next_addr;

    16 static void		*base_past_addr; /* Addr immediately past base_pages. */

    17 static extent_node_t	*base_nodes;

    19 /******************************************************************************/

    20 /* Function prototypes for non-inline static functions. */

    22 static bool	base_pages_alloc(size_t minsize);

    24 /******************************************************************************/

    26 static bool

    27 base_pages_alloc(size_t minsize)

    28 {

    29 	size_t csize;

    30 	bool zero;

    32 	assert(minsize != 0);

    33 	csize = CHUNK_CEILING(minsize);

    34 	zero = false;

    35 	base_pages = chunk_alloc(csize, chunksize, true, &zero,

    36 	    chunk_dss_prec_get());

    37 	if (base_pages == NULL)

    38 		return (true);

    39 	base_next_addr = base_pages;

    40 	base_past_addr = (void *)((uintptr_t)base_pages + csize);

    42 	return (false);

    43 }

    45 void *

    46 base_alloc(size_t size)

    47 {

    48 	void *ret;

    49 	size_t csize;

    51 	/* Round size up to nearest multiple of the cacheline size. */

    52 	csize = CACHELINE_CEILING(size);

    54 	malloc_mutex_lock(&base_mtx);

    55 	/* Make sure there's enough space for the allocation. */

    56 	if ((uintptr_t)base_next_addr + csize > (uintptr_t)base_past_addr) {

    57 		if (base_pages_alloc(csize)) {

    58 			malloc_mutex_unlock(&base_mtx);

    59 			return (NULL);

    60 		}

    61 	}

    62 	/* Allocate. */

    63 	ret = base_next_addr;

    64 	base_next_addr = (void *)((uintptr_t)base_next_addr + csize);

    65 	malloc_mutex_unlock(&base_mtx);

    67 	return (ret);

    68 }

    70 void *

    71 base_calloc(size_t number, size_t size)

    72 {

    73 	void *ret = base_alloc(number * size);

    75 	if (ret != NULL)

    76 		memset(ret, 0, number * size);

    78 	return (ret);

    79 }

    81 extent_node_t *

    82 base_node_alloc(void)

    83 {

    84 	extent_node_t *ret;

    86 	malloc_mutex_lock(&base_mtx);

    87 	if (base_nodes != NULL) {

    88 		ret = base_nodes;

    89 		base_nodes = *(extent_node_t **)ret;

    90 		malloc_mutex_unlock(&base_mtx);

    91 	} else {

    92 		malloc_mutex_unlock(&base_mtx);

    93 		ret = (extent_node_t *)base_alloc(sizeof(extent_node_t));

    94 	}

    96 	return (ret);

    97 }

    99 void

   100 base_node_dealloc(extent_node_t *node)

   101 {

   103 	malloc_mutex_lock(&base_mtx);

   104 	*(extent_node_t **)node = base_nodes;

   105 	base_nodes = node;

   106 	malloc_mutex_unlock(&base_mtx);

   107 }

   109 bool

   110 base_boot(void)

   111 {

   113 	base_nodes = NULL;

   114 	if (malloc_mutex_init(&base_mtx))

   115 		return (true);

   117 	return (false);

   118 }

   120 void

   121 base_prefork(void)

   122 {

   124 	malloc_mutex_prefork(&base_mtx);

   125 }

   127 void

   128 base_postfork_parent(void)

   129 {

   131 	malloc_mutex_postfork_parent(&base_mtx);

   132 }

   134 void

   135 base_postfork_child(void)

   136 {

   138 	malloc_mutex_postfork_child(&base_mtx);

   139 }

The Tor Browser / file revision