1234370Sjasonediff --git a/doc/jemalloc.xml.in b/doc/jemalloc.xml.in 2299587Sjasoneindex c4a44e3..4626e9b 100644 3234370Sjasone--- a/doc/jemalloc.xml.in 4234370Sjasone+++ b/doc/jemalloc.xml.in 5286911Sjasone@@ -53,11 +53,23 @@ 6234370Sjasone <para>This manual describes jemalloc @jemalloc_version@. More information 7234370Sjasone can be found at the <ulink 8234370Sjasone url="http://www.canonware.com/jemalloc/">jemalloc website</ulink>.</para> 9234370Sjasone+ 10234370Sjasone+ <para>The following configuration options are enabled in libc's built-in 11286866Sjasone+ jemalloc: <option>--enable-fill</option>, 12234370Sjasone+ <option>--enable-lazy-lock</option>, <option>--enable-munmap</option>, 13234370Sjasone+ <option>--enable-stats</option>, <option>--enable-tcache</option>, 14234370Sjasone+ <option>--enable-tls</option>, <option>--enable-utrace</option>, and 15234370Sjasone+ <option>--enable-xmalloc</option>. Additionally, 16234370Sjasone+ <option>--enable-debug</option> is enabled in development versions of 17365662Sdim+ FreeBSD (controlled by the <constant>MK_MALLOC_PRODUCTION</constant> make 18234370Sjasone+ variable).</para> 19286866Sjasone+ 20234370Sjasone </refsect1> 21234370Sjasone <refsynopsisdiv> 22234370Sjasone <title>SYNOPSIS</title> 23286911Sjasone <funcsynopsis> 24286911Sjasone- <funcsynopsisinfo>#include <<filename class="headerfile">jemalloc/jemalloc.h</filename>></funcsynopsisinfo> 25286911Sjasone+ <funcsynopsisinfo>#include <<filename class="headerfile">stdlib.h</filename>> 26286911Sjasone+#include <<filename class="headerfile">malloc_np.h</filename>></funcsynopsisinfo> 27286911Sjasone <refsect2> 28286911Sjasone <title>Standard API</title> 29286911Sjasone <funcprototype> 30299587Sjasone@@ -2961,4 +2973,18 @@ malloc_conf = "lg_chunk:24";]]></programlisting></para> 31234370Sjasone <para>The <function>posix_memalign<parameter/></function> function conforms 32234370Sjasone to IEEE Std 1003.1-2001 (“POSIX.1”).</para> 33234370Sjasone </refsect1> 34234370Sjasone+ <refsect1 id="history"> 35234370Sjasone+ <title>HISTORY</title> 36234370Sjasone+ <para>The <function>malloc_usable_size<parameter/></function> and 37234370Sjasone+ <function>posix_memalign<parameter/></function> functions first appeared in 38234370Sjasone+ FreeBSD 7.0.</para> 39234370Sjasone+ 40234370Sjasone+ <para>The <function>aligned_alloc<parameter/></function>, 41286866Sjasone+ <function>malloc_stats_print<parameter/></function>, and 42286866Sjasone+ <function>mallctl*<parameter/></function> functions first appeared in 43234370Sjasone+ FreeBSD 10.0.</para> 44261071Sjasone+ 45261071Sjasone+ <para>The <function>*allocx<parameter/></function> functions first appeared 46261071Sjasone+ in FreeBSD 11.0.</para> 47234370Sjasone+ </refsect1> 48234370Sjasone </refentry> 49299700Sjasonediff --git a/include/jemalloc/internal/arena.h b/include/jemalloc/internal/arena.h 50299700Sjasoneindex b1de2b6..da6b6d2 100644 51299700Sjasone--- a/include/jemalloc/internal/arena.h 52299700Sjasone+++ b/include/jemalloc/internal/arena.h 53299700Sjasone@@ -718,8 +718,13 @@ arena_miscelm_get_mutable(arena_chunk_t *chunk, size_t pageind) 54299700Sjasone JEMALLOC_ALWAYS_INLINE const arena_chunk_map_misc_t * 55299700Sjasone arena_miscelm_get_const(const arena_chunk_t *chunk, size_t pageind) 56299700Sjasone { 57299700Sjasone+#if 1 /* Work around gcc bug. */ 58299700Sjasone+ arena_chunk_t *mchunk = (arena_chunk_t *)chunk; 59299700Sjasone 60299700Sjasone+ return (arena_miscelm_get_mutable(mchunk, pageind)); 61299700Sjasone+#else 62299700Sjasone return (arena_miscelm_get_mutable((arena_chunk_t *)chunk, pageind)); 63299700Sjasone+#endif 64299700Sjasone } 65299700Sjasone 66299700Sjasone JEMALLOC_ALWAYS_INLINE size_t 67299700Sjasone@@ -778,8 +783,13 @@ arena_mapbitsp_get_mutable(arena_chunk_t *chunk, size_t pageind) 68299700Sjasone JEMALLOC_ALWAYS_INLINE const size_t * 69299700Sjasone arena_mapbitsp_get_const(const arena_chunk_t *chunk, size_t pageind) 70299700Sjasone { 71299700Sjasone+#if 1 /* Work around gcc bug. */ 72299700Sjasone+ arena_chunk_t *mchunk = (arena_chunk_t *)chunk; 73299700Sjasone 74299700Sjasone+ return (arena_mapbitsp_get_mutable(mchunk, pageind)); 75299700Sjasone+#else 76299700Sjasone return (arena_mapbitsp_get_mutable((arena_chunk_t *)chunk, pageind)); 77299700Sjasone+#endif 78299700Sjasone } 79299700Sjasone 80299700Sjasone JEMALLOC_ALWAYS_INLINE size_t 81234370Sjasonediff --git a/include/jemalloc/internal/jemalloc_internal.h.in b/include/jemalloc/internal/jemalloc_internal.h.in 82301718Sjasoneindex 8f82edd..78e2df2 100644 83234370Sjasone--- a/include/jemalloc/internal/jemalloc_internal.h.in 84234370Sjasone+++ b/include/jemalloc/internal/jemalloc_internal.h.in 85286866Sjasone@@ -8,6 +8,9 @@ 86286866Sjasone #include <sys/ktrace.h> 87235238Sjasone #endif 88234370Sjasone 89234370Sjasone+#include "un-namespace.h" 90234370Sjasone+#include "libc_private.h" 91234370Sjasone+ 92234370Sjasone #define JEMALLOC_NO_DEMANGLE 93261071Sjasone #ifdef JEMALLOC_JET 94261071Sjasone # define JEMALLOC_N(n) jet_##n 95286866Sjasone@@ -42,13 +45,7 @@ static const bool config_fill = 96235385Sjasone false 97235385Sjasone #endif 98235385Sjasone ; 99235385Sjasone-static const bool config_lazy_lock = 100235385Sjasone-#ifdef JEMALLOC_LAZY_LOCK 101235385Sjasone- true 102235385Sjasone-#else 103235385Sjasone- false 104235385Sjasone-#endif 105235385Sjasone- ; 106235385Sjasone+static const bool config_lazy_lock = true; 107296221Sjasone static const char * const config_malloc_conf = JEMALLOC_CONFIG_MALLOC_CONF; 108235385Sjasone static const bool config_prof = 109235385Sjasone #ifdef JEMALLOC_PROF 110286866Sjasonediff --git a/include/jemalloc/internal/jemalloc_internal_decls.h b/include/jemalloc/internal/jemalloc_internal_decls.h 111296221Sjasoneindex 2b8ca5d..42d97f2 100644 112286866Sjasone--- a/include/jemalloc/internal/jemalloc_internal_decls.h 113286866Sjasone+++ b/include/jemalloc/internal/jemalloc_internal_decls.h 114286866Sjasone@@ -1,6 +1,9 @@ 115286866Sjasone #ifndef JEMALLOC_INTERNAL_DECLS_H 116286866Sjasone #define JEMALLOC_INTERNAL_DECLS_H 117286866Sjasone 118286866Sjasone+#include "libc_private.h" 119286866Sjasone+#include "namespace.h" 120286866Sjasone+ 121286866Sjasone #include <math.h> 122286866Sjasone #ifdef _WIN32 123286866Sjasone # include <windows.h> 124234370Sjasonediff --git a/include/jemalloc/internal/mutex.h b/include/jemalloc/internal/mutex.h 125299587Sjasoneindex 5221799..60ab041 100644 126234370Sjasone--- a/include/jemalloc/internal/mutex.h 127234370Sjasone+++ b/include/jemalloc/internal/mutex.h 128299587Sjasone@@ -52,9 +52,6 @@ struct malloc_mutex_s { 129234370Sjasone 130234370Sjasone #ifdef JEMALLOC_LAZY_LOCK 131234370Sjasone extern bool isthreaded; 132234370Sjasone-#else 133234543Sjasone-# undef isthreaded /* Undo private_namespace.h definition. */ 134234370Sjasone-# define isthreaded true 135234370Sjasone #endif 136234370Sjasone 137299587Sjasone bool malloc_mutex_init(malloc_mutex_t *mutex, const char *name, 138299587Sjasone@@ -62,6 +59,7 @@ bool malloc_mutex_init(malloc_mutex_t *mutex, const char *name, 139299587Sjasone void malloc_mutex_prefork(tsdn_t *tsdn, malloc_mutex_t *mutex); 140299587Sjasone void malloc_mutex_postfork_parent(tsdn_t *tsdn, malloc_mutex_t *mutex); 141299587Sjasone void malloc_mutex_postfork_child(tsdn_t *tsdn, malloc_mutex_t *mutex); 142286866Sjasone+bool malloc_mutex_first_thread(void); 143299587Sjasone bool malloc_mutex_boot(void); 144286866Sjasone 145286866Sjasone #endif /* JEMALLOC_H_EXTERNS */ 146261071Sjasonediff --git a/include/jemalloc/internal/private_symbols.txt b/include/jemalloc/internal/private_symbols.txt 147299587Sjasoneindex f2b6a55..69369c9 100644 148261071Sjasone--- a/include/jemalloc/internal/private_symbols.txt 149261071Sjasone+++ b/include/jemalloc/internal/private_symbols.txt 150299587Sjasone@@ -311,7 +311,6 @@ iralloct_realign 151261071Sjasone isalloc 152286866Sjasone isdalloct 153286866Sjasone isqalloc 154261071Sjasone-isthreaded 155261071Sjasone ivsalloc 156261071Sjasone ixalloc 157261071Sjasone jemalloc_postfork_child 158234370Sjasonediff --git a/include/jemalloc/jemalloc_FreeBSD.h b/include/jemalloc/jemalloc_FreeBSD.h 159234370Sjasonenew file mode 100644 160299587Sjasoneindex 0000000..c58a8f3 161234370Sjasone--- /dev/null 162234370Sjasone+++ b/include/jemalloc/jemalloc_FreeBSD.h 163299587Sjasone@@ -0,0 +1,162 @@ 164234370Sjasone+/* 165234370Sjasone+ * Override settings that were generated in jemalloc_defs.h as necessary. 166234370Sjasone+ */ 167234370Sjasone+ 168234370Sjasone+#undef JEMALLOC_OVERRIDE_VALLOC 169234370Sjasone+ 170234370Sjasone+#ifndef MALLOC_PRODUCTION 171234370Sjasone+#define JEMALLOC_DEBUG 172234370Sjasone+#endif 173234370Sjasone+ 174299587Sjasone+#undef JEMALLOC_DSS 175299587Sjasone+ 176234370Sjasone+/* 177234370Sjasone+ * The following are architecture-dependent, so conditionally define them for 178234370Sjasone+ * each supported architecture. 179234370Sjasone+ */ 180234370Sjasone+#undef JEMALLOC_TLS_MODEL 181234370Sjasone+#undef STATIC_PAGE_SHIFT 182234370Sjasone+#undef LG_SIZEOF_PTR 183234370Sjasone+#undef LG_SIZEOF_INT 184234370Sjasone+#undef LG_SIZEOF_LONG 185234370Sjasone+#undef LG_SIZEOF_INTMAX_T 186234370Sjasone+ 187234370Sjasone+#ifdef __i386__ 188234370Sjasone+# define LG_SIZEOF_PTR 2 189234370Sjasone+# define JEMALLOC_TLS_MODEL __attribute__((tls_model("initial-exec"))) 190234370Sjasone+#endif 191234370Sjasone+#ifdef __ia64__ 192234370Sjasone+# define LG_SIZEOF_PTR 3 193234370Sjasone+#endif 194234370Sjasone+#ifdef __sparc64__ 195234370Sjasone+# define LG_SIZEOF_PTR 3 196234370Sjasone+# define JEMALLOC_TLS_MODEL __attribute__((tls_model("initial-exec"))) 197234370Sjasone+#endif 198234370Sjasone+#ifdef __amd64__ 199234370Sjasone+# define LG_SIZEOF_PTR 3 200234370Sjasone+# define JEMALLOC_TLS_MODEL __attribute__((tls_model("initial-exec"))) 201234370Sjasone+#endif 202234370Sjasone+#ifdef __arm__ 203234370Sjasone+# define LG_SIZEOF_PTR 2 204234370Sjasone+#endif 205286877Sjasone+#ifdef __aarch64__ 206286877Sjasone+# define LG_SIZEOF_PTR 3 207286877Sjasone+#endif 208234370Sjasone+#ifdef __mips__ 209235238Sjasone+#ifdef __mips_n64 210235238Sjasone+# define LG_SIZEOF_PTR 3 211235238Sjasone+#else 212234370Sjasone+# define LG_SIZEOF_PTR 2 213234370Sjasone+#endif 214235238Sjasone+#endif 215234370Sjasone+#ifdef __powerpc64__ 216234370Sjasone+# define LG_SIZEOF_PTR 3 217234370Sjasone+#elif defined(__powerpc__) 218234370Sjasone+# define LG_SIZEOF_PTR 2 219234370Sjasone+#endif 220296221Sjasone+#ifdef __riscv__ 221296221Sjasone+# define LG_SIZEOF_PTR 3 222296221Sjasone+#endif 223234370Sjasone+ 224234370Sjasone+#ifndef JEMALLOC_TLS_MODEL 225234370Sjasone+# define JEMALLOC_TLS_MODEL /* Default. */ 226234370Sjasone+#endif 227234370Sjasone+ 228234370Sjasone+#define STATIC_PAGE_SHIFT PAGE_SHIFT 229234370Sjasone+#define LG_SIZEOF_INT 2 230234370Sjasone+#define LG_SIZEOF_LONG LG_SIZEOF_PTR 231234370Sjasone+#define LG_SIZEOF_INTMAX_T 3 232234370Sjasone+ 233286907Sjasone+#undef CPU_SPINWAIT 234286907Sjasone+#include <machine/cpu.h> 235286907Sjasone+#include <machine/cpufunc.h> 236286907Sjasone+#define CPU_SPINWAIT cpu_spinwait() 237286907Sjasone+ 238234370Sjasone+/* Disable lazy-lock machinery, mangle isthreaded, and adjust its type. */ 239234370Sjasone+#undef JEMALLOC_LAZY_LOCK 240234370Sjasone+extern int __isthreaded; 241234370Sjasone+#define isthreaded ((bool)__isthreaded) 242234370Sjasone+ 243234370Sjasone+/* Mangle. */ 244251300Sjasone+#undef je_malloc 245251300Sjasone+#undef je_calloc 246296221Sjasone+#undef je_posix_memalign 247296221Sjasone+#undef je_aligned_alloc 248251300Sjasone+#undef je_realloc 249251300Sjasone+#undef je_free 250251300Sjasone+#undef je_malloc_usable_size 251261071Sjasone+#undef je_mallocx 252261071Sjasone+#undef je_rallocx 253261071Sjasone+#undef je_xallocx 254261071Sjasone+#undef je_sallocx 255261071Sjasone+#undef je_dallocx 256296221Sjasone+#undef je_sdallocx 257261071Sjasone+#undef je_nallocx 258296221Sjasone+#undef je_mallctl 259296221Sjasone+#undef je_mallctlnametomib 260296221Sjasone+#undef je_mallctlbymib 261296221Sjasone+#undef je_malloc_stats_print 262251300Sjasone+#undef je_allocm 263251300Sjasone+#undef je_rallocm 264251300Sjasone+#undef je_sallocm 265251300Sjasone+#undef je_dallocm 266251300Sjasone+#undef je_nallocm 267251300Sjasone+#define je_malloc __malloc 268251300Sjasone+#define je_calloc __calloc 269296221Sjasone+#define je_posix_memalign __posix_memalign 270296221Sjasone+#define je_aligned_alloc __aligned_alloc 271251300Sjasone+#define je_realloc __realloc 272251300Sjasone+#define je_free __free 273251300Sjasone+#define je_malloc_usable_size __malloc_usable_size 274261071Sjasone+#define je_mallocx __mallocx 275261071Sjasone+#define je_rallocx __rallocx 276261071Sjasone+#define je_xallocx __xallocx 277261071Sjasone+#define je_sallocx __sallocx 278261071Sjasone+#define je_dallocx __dallocx 279296221Sjasone+#define je_sdallocx __sdallocx 280261071Sjasone+#define je_nallocx __nallocx 281296221Sjasone+#define je_mallctl __mallctl 282296221Sjasone+#define je_mallctlnametomib __mallctlnametomib 283296221Sjasone+#define je_mallctlbymib __mallctlbymib 284296221Sjasone+#define je_malloc_stats_print __malloc_stats_print 285251300Sjasone+#define je_allocm __allocm 286251300Sjasone+#define je_rallocm __rallocm 287251300Sjasone+#define je_sallocm __sallocm 288251300Sjasone+#define je_dallocm __dallocm 289251300Sjasone+#define je_nallocm __nallocm 290234370Sjasone+#define open _open 291234370Sjasone+#define read _read 292234370Sjasone+#define write _write 293234370Sjasone+#define close _close 294234370Sjasone+#define pthread_mutex_lock _pthread_mutex_lock 295234370Sjasone+#define pthread_mutex_unlock _pthread_mutex_unlock 296251300Sjasone+ 297251300Sjasone+#ifdef JEMALLOC_C_ 298251300Sjasone+/* 299251300Sjasone+ * Define 'weak' symbols so that an application can have its own versions 300251300Sjasone+ * of malloc, calloc, realloc, free, et al. 301251300Sjasone+ */ 302251300Sjasone+__weak_reference(__malloc, malloc); 303251300Sjasone+__weak_reference(__calloc, calloc); 304296221Sjasone+__weak_reference(__posix_memalign, posix_memalign); 305296221Sjasone+__weak_reference(__aligned_alloc, aligned_alloc); 306251300Sjasone+__weak_reference(__realloc, realloc); 307251300Sjasone+__weak_reference(__free, free); 308251300Sjasone+__weak_reference(__malloc_usable_size, malloc_usable_size); 309261071Sjasone+__weak_reference(__mallocx, mallocx); 310261071Sjasone+__weak_reference(__rallocx, rallocx); 311261071Sjasone+__weak_reference(__xallocx, xallocx); 312261071Sjasone+__weak_reference(__sallocx, sallocx); 313261071Sjasone+__weak_reference(__dallocx, dallocx); 314296221Sjasone+__weak_reference(__sdallocx, sdallocx); 315261071Sjasone+__weak_reference(__nallocx, nallocx); 316296221Sjasone+__weak_reference(__mallctl, mallctl); 317296221Sjasone+__weak_reference(__mallctlnametomib, mallctlnametomib); 318296221Sjasone+__weak_reference(__mallctlbymib, mallctlbymib); 319296221Sjasone+__weak_reference(__malloc_stats_print, malloc_stats_print); 320251300Sjasone+__weak_reference(__allocm, allocm); 321251300Sjasone+__weak_reference(__rallocm, rallocm); 322251300Sjasone+__weak_reference(__sallocm, sallocm); 323251300Sjasone+__weak_reference(__dallocm, dallocm); 324251300Sjasone+__weak_reference(__nallocm, nallocm); 325251300Sjasone+#endif 326261071Sjasonediff --git a/include/jemalloc/jemalloc_rename.sh b/include/jemalloc/jemalloc_rename.sh 327261071Sjasoneindex f943891..47d032c 100755 328261071Sjasone--- a/include/jemalloc/jemalloc_rename.sh 329261071Sjasone+++ b/include/jemalloc/jemalloc_rename.sh 330261071Sjasone@@ -19,4 +19,6 @@ done 331261071Sjasone 332261071Sjasone cat <<EOF 333261071Sjasone #endif 334251300Sjasone+ 335261071Sjasone+#include "jemalloc_FreeBSD.h" 336261071Sjasone EOF 337234370Sjasonediff --git a/src/jemalloc.c b/src/jemalloc.c 338301718Sjasoneindex 5d1f493..46dd1d1 100644 339234370Sjasone--- a/src/jemalloc.c 340234370Sjasone+++ b/src/jemalloc.c 341286866Sjasone@@ -4,6 +4,10 @@ 342286866Sjasone /******************************************************************************/ 343286866Sjasone /* Data. */ 344234370Sjasone 345235238Sjasone+/* Work around <http://llvm.org/bugs/show_bug.cgi?id=12623>: */ 346235238Sjasone+const char *__malloc_options_1_0 = NULL; 347234370Sjasone+__sym_compat(_malloc_options, __malloc_options_1_0, FBSD_1.0); 348234370Sjasone+ 349234370Sjasone /* Runtime configuration options. */ 350286866Sjasone const char *je_malloc_conf JEMALLOC_ATTR(weak); 351245868Sjasone bool opt_abort = 352299587Sjasone@@ -2673,6 +2677,107 @@ je_malloc_usable_size(JEMALLOC_USABLE_SIZE_CONST void *ptr) 353286866Sjasone */ 354286866Sjasone /******************************************************************************/ 355286866Sjasone /* 356286866Sjasone+ * Begin compatibility functions. 357286866Sjasone+ */ 358286866Sjasone+ 359286866Sjasone+#define ALLOCM_LG_ALIGN(la) (la) 360286866Sjasone+#define ALLOCM_ALIGN(a) (ffsl(a)-1) 361286866Sjasone+#define ALLOCM_ZERO ((int)0x40) 362286866Sjasone+#define ALLOCM_NO_MOVE ((int)0x80) 363286866Sjasone+ 364286866Sjasone+#define ALLOCM_SUCCESS 0 365286866Sjasone+#define ALLOCM_ERR_OOM 1 366286866Sjasone+#define ALLOCM_ERR_NOT_MOVED 2 367286866Sjasone+ 368286866Sjasone+int 369286866Sjasone+je_allocm(void **ptr, size_t *rsize, size_t size, int flags) 370286866Sjasone+{ 371286866Sjasone+ void *p; 372286866Sjasone+ 373286866Sjasone+ assert(ptr != NULL); 374286866Sjasone+ 375286866Sjasone+ p = je_mallocx(size, flags); 376286866Sjasone+ if (p == NULL) 377286866Sjasone+ return (ALLOCM_ERR_OOM); 378286866Sjasone+ if (rsize != NULL) 379299587Sjasone+ *rsize = isalloc(tsdn_fetch(), p, config_prof); 380286866Sjasone+ *ptr = p; 381286866Sjasone+ return (ALLOCM_SUCCESS); 382286866Sjasone+} 383286866Sjasone+ 384286866Sjasone+int 385286866Sjasone+je_rallocm(void **ptr, size_t *rsize, size_t size, size_t extra, int flags) 386286866Sjasone+{ 387286866Sjasone+ int ret; 388286866Sjasone+ bool no_move = flags & ALLOCM_NO_MOVE; 389286866Sjasone+ 390286866Sjasone+ assert(ptr != NULL); 391286866Sjasone+ assert(*ptr != NULL); 392286866Sjasone+ assert(size != 0); 393286866Sjasone+ assert(SIZE_T_MAX - size >= extra); 394286866Sjasone+ 395286866Sjasone+ if (no_move) { 396286866Sjasone+ size_t usize = je_xallocx(*ptr, size, extra, flags); 397286866Sjasone+ ret = (usize >= size) ? ALLOCM_SUCCESS : ALLOCM_ERR_NOT_MOVED; 398286866Sjasone+ if (rsize != NULL) 399286866Sjasone+ *rsize = usize; 400286866Sjasone+ } else { 401286866Sjasone+ void *p = je_rallocx(*ptr, size+extra, flags); 402286866Sjasone+ if (p != NULL) { 403286866Sjasone+ *ptr = p; 404286866Sjasone+ ret = ALLOCM_SUCCESS; 405286866Sjasone+ } else 406286866Sjasone+ ret = ALLOCM_ERR_OOM; 407286866Sjasone+ if (rsize != NULL) 408299587Sjasone+ *rsize = isalloc(tsdn_fetch(), *ptr, config_prof); 409286866Sjasone+ } 410286866Sjasone+ return (ret); 411286866Sjasone+} 412286866Sjasone+ 413286866Sjasone+int 414286866Sjasone+je_sallocm(const void *ptr, size_t *rsize, int flags) 415286866Sjasone+{ 416286866Sjasone+ 417286866Sjasone+ assert(rsize != NULL); 418286866Sjasone+ *rsize = je_sallocx(ptr, flags); 419286866Sjasone+ return (ALLOCM_SUCCESS); 420286866Sjasone+} 421286866Sjasone+ 422286866Sjasone+int 423286866Sjasone+je_dallocm(void *ptr, int flags) 424286866Sjasone+{ 425286866Sjasone+ 426286866Sjasone+ je_dallocx(ptr, flags); 427286866Sjasone+ return (ALLOCM_SUCCESS); 428286866Sjasone+} 429286866Sjasone+ 430286866Sjasone+int 431286866Sjasone+je_nallocm(size_t *rsize, size_t size, int flags) 432286866Sjasone+{ 433286866Sjasone+ size_t usize; 434286866Sjasone+ 435286866Sjasone+ usize = je_nallocx(size, flags); 436286866Sjasone+ if (usize == 0) 437286866Sjasone+ return (ALLOCM_ERR_OOM); 438286866Sjasone+ if (rsize != NULL) 439286866Sjasone+ *rsize = usize; 440286866Sjasone+ return (ALLOCM_SUCCESS); 441286866Sjasone+} 442286866Sjasone+ 443286866Sjasone+#undef ALLOCM_LG_ALIGN 444286866Sjasone+#undef ALLOCM_ALIGN 445286866Sjasone+#undef ALLOCM_ZERO 446286866Sjasone+#undef ALLOCM_NO_MOVE 447286866Sjasone+ 448286866Sjasone+#undef ALLOCM_SUCCESS 449286866Sjasone+#undef ALLOCM_ERR_OOM 450286866Sjasone+#undef ALLOCM_ERR_NOT_MOVED 451286866Sjasone+ 452286866Sjasone+/* 453286866Sjasone+ * End compatibility functions. 454286866Sjasone+ */ 455286866Sjasone+/******************************************************************************/ 456286866Sjasone+/* 457286866Sjasone * The following functions are used by threading libraries for protection of 458286866Sjasone * malloc during fork(). 459286866Sjasone */ 460299587Sjasone@@ -2814,4 +2919,11 @@ jemalloc_postfork_child(void) 461299587Sjasone ctl_postfork_child(tsd_tsdn(tsd)); 462286866Sjasone } 463234370Sjasone 464286866Sjasone+void 465286866Sjasone+_malloc_first_thread(void) 466286866Sjasone+{ 467286866Sjasone+ 468286866Sjasone+ (void)malloc_mutex_first_thread(); 469286866Sjasone+} 470286866Sjasone+ 471286866Sjasone /******************************************************************************/ 472234370Sjasonediff --git a/src/mutex.c b/src/mutex.c 473299587Sjasoneindex a1fac34..a24e420 100644 474234370Sjasone--- a/src/mutex.c 475234370Sjasone+++ b/src/mutex.c 476235238Sjasone@@ -66,6 +66,17 @@ pthread_create(pthread_t *__restrict thread, 477234370Sjasone #ifdef JEMALLOC_MUTEX_INIT_CB 478242844Sjasone JEMALLOC_EXPORT int _pthread_mutex_init_calloc_cb(pthread_mutex_t *mutex, 479234370Sjasone void *(calloc_cb)(size_t, size_t)); 480234370Sjasone+ 481286866Sjasone+#pragma weak _pthread_mutex_init_calloc_cb 482234370Sjasone+int 483286866Sjasone+_pthread_mutex_init_calloc_cb(pthread_mutex_t *mutex, 484234370Sjasone+ void *(calloc_cb)(size_t, size_t)) 485234370Sjasone+{ 486234370Sjasone+ 487286866Sjasone+ return (((int (*)(pthread_mutex_t *, void *(*)(size_t, size_t))) 488286866Sjasone+ __libc_interposing[INTERPOS__pthread_mutex_init_calloc_cb])(mutex, 489286866Sjasone+ calloc_cb)); 490234370Sjasone+} 491234370Sjasone #endif 492234370Sjasone 493234370Sjasone bool 494299587Sjasone@@ -140,7 +151,7 @@ malloc_mutex_postfork_child(tsdn_t *tsdn, malloc_mutex_t *mutex) 495286866Sjasone } 496286866Sjasone 497286866Sjasone bool 498299587Sjasone-malloc_mutex_boot(void) 499286866Sjasone+malloc_mutex_first_thread(void) 500286866Sjasone { 501286866Sjasone 502286866Sjasone #ifdef JEMALLOC_MUTEX_INIT_CB 503299587Sjasone@@ -154,3 +165,14 @@ malloc_mutex_boot(void) 504286866Sjasone #endif 505286866Sjasone return (false); 506286866Sjasone } 507286866Sjasone+ 508286866Sjasone+bool 509299587Sjasone+malloc_mutex_boot(void) 510286866Sjasone+{ 511286866Sjasone+ 512286866Sjasone+#ifndef JEMALLOC_MUTEX_INIT_CB 513286866Sjasone+ return (malloc_mutex_first_thread()); 514286866Sjasone+#else 515286866Sjasone+ return (false); 516286866Sjasone+#endif 517286866Sjasone+} 518234370Sjasonediff --git a/src/util.c b/src/util.c 519299587Sjasoneindex a1c4a2a..04f9153 100644 520234370Sjasone--- a/src/util.c 521234370Sjasone+++ b/src/util.c 522299587Sjasone@@ -67,6 +67,22 @@ wrtmessage(void *cbopaque, const char *s) 523234370Sjasone 524235238Sjasone JEMALLOC_EXPORT void (*je_malloc_message)(void *, const char *s); 525235238Sjasone 526235238Sjasone+JEMALLOC_ATTR(visibility("hidden")) 527234370Sjasone+void 528234370Sjasone+wrtmessage_1_0(const char *s1, const char *s2, const char *s3, 529234370Sjasone+ const char *s4) 530234370Sjasone+{ 531234370Sjasone+ 532234370Sjasone+ wrtmessage(NULL, s1); 533234370Sjasone+ wrtmessage(NULL, s2); 534234370Sjasone+ wrtmessage(NULL, s3); 535234370Sjasone+ wrtmessage(NULL, s4); 536234370Sjasone+} 537234370Sjasone+ 538234370Sjasone+void (*__malloc_message_1_0)(const char *s1, const char *s2, const char *s3, 539234370Sjasone+ const char *s4) = wrtmessage_1_0; 540234370Sjasone+__sym_compat(_malloc_message, __malloc_message_1_0, FBSD_1.0); 541234370Sjasone+ 542234370Sjasone /* 543235238Sjasone * Wrapper around malloc_message() that avoids the need for 544235238Sjasone * je_malloc_message(...) throughout the code. 545