#include "mimalloc.h"
#include "mimalloc/prim.h"
#include "mimalloc/prim/prim-tls.h"
#include "mimalloc/alloc/page.h"
#include "mimalloc/util/options.h"
#include "mimalloc/heap/process.h"
#include <stdio.h>
#include <stdlib.h>
static void mi_add_stderr_output(void);
int mi_version(void) {
return MI_MALLOC_VERSION;
}
#define MI_OPTION(opt) mi_option_##opt, #opt, NULL
#define MI_OPTION_LEGACY(opt,legacy) mi_option_##opt, #opt, #legacy
#ifndef MI_DEFAULT_VERBOSE
#define MI_DEFAULT_VERBOSE 0
#endif
#ifndef MI_DEFAULT_ARENA_EAGER_COMMIT
#define MI_DEFAULT_ARENA_EAGER_COMMIT 2
#endif
#ifndef MI_DEFAULT_ARENA_RESERVE
#if (MI_SIZE_SIZE>4)
#define MI_DEFAULT_ARENA_RESERVE 1024L*1024L
#else
#define MI_DEFAULT_ARENA_RESERVE 128L*1024L
#endif
#endif
#ifndef MI_DEFAULT_ARENA_MAX_OBJECT_SIZE
#define MI_DEFAULT_ARENA_MAX_OBJECT_SIZE ((MI_SIZE_BITS * MI_ARENA_MAX_CHUNK_OBJ_SIZE)/MI_KiB)
#endif
#ifndef MI_DEFAULT_DISALLOW_ARENA_ALLOC
#define MI_DEFAULT_DISALLOW_ARENA_ALLOC 0
#endif
#ifndef MI_DEFAULT_ALLOW_LARGE_OS_PAGES
#define MI_DEFAULT_ALLOW_LARGE_OS_PAGES 0
#endif
#ifndef MI_DEFAULT_RESERVE_HUGE_OS_PAGES
#define MI_DEFAULT_RESERVE_HUGE_OS_PAGES 0
#endif
#ifndef MI_DEFAULT_RESERVE_OS_MEMORY
#define MI_DEFAULT_RESERVE_OS_MEMORY 0
#endif
#ifndef MI_DEFAULT_GUARDED_SAMPLE_RATE
#if MI_GUARDED && MI_DEBUG
#define MI_DEFAULT_GUARDED_SAMPLE_RATE 0
#else
#define MI_DEFAULT_GUARDED_SAMPLE_RATE 0
#endif
#endif
#ifndef MI_DEFAULT_PAGEMAP_COMMIT
#define MI_DEFAULT_PAGEMAP_COMMIT 0
#endif
#ifndef MI_DEFAULT_PAGE_MAX_RECLAIM
#define MI_DEFAULT_PAGE_MAX_RECLAIM (-1)
#endif
#ifndef MI_DEFAULT_PAGE_FULL_RETAIN
#define MI_DEFAULT_PAGE_FULL_RETAIN 2
#endif
#ifndef MI_DEFAULT_PAGE_CROSS_THREAD_MAX_RECLAIM
#define MI_DEFAULT_PAGE_CROSS_THREAD_MAX_RECLAIM 32
#endif
#ifndef MI_DEFAULT_ALLOW_THP
#if defined(__ANDROID__)
#define MI_DEFAULT_ALLOW_THP 0
#else
#define MI_DEFAULT_ALLOW_THP 2
#endif
#endif
#ifndef MI_DEFAULT_STATS_MERGE_ON_COLLECT
#define MI_DEFAULT_STATS_MERGE_ON_COLLECT 1
#endif
#ifndef MI_DEFAULT_STATS_MERGE_THRESHOLD
#define MI_DEFAULT_STATS_MERGE_THRESHOLD (4*1024*1024)
#endif
#ifndef MI_DEFAULT_ARENA_PURGE_IMMEDIATE_SIZE
#define MI_DEFAULT_ARENA_PURGE_IMMEDIATE_SIZE ((MI_SIZE_SIZE * MI_LARGE_PAGE_SIZE) / MI_KiB)
#endif
static const mi_option_desc_t mi_option_descs[_mi_option_last] =
{
#if MI_DEBUG || defined(MI_SHOW_ERRORS)
{ 1, MI_OPTION(show_errors) },
#else
{ 0, MI_OPTION(show_errors) },
#endif
{ 0, MI_OPTION(show_stats) },
{ MI_DEFAULT_VERBOSE, MI_OPTION(verbose) },
{ 1, MI_OPTION(deprecated_eager_commit) },
{ MI_DEFAULT_ARENA_EAGER_COMMIT, MI_OPTION_LEGACY(arena_eager_commit,eager_region_commit) }, { 1, MI_OPTION_LEGACY(purge_decommits,reset_decommits) }, { MI_DEFAULT_ALLOW_LARGE_OS_PAGES, MI_OPTION_LEGACY(allow_large_os_pages,large_os_pages) }, { MI_DEFAULT_RESERVE_HUGE_OS_PAGES, MI_OPTION(reserve_huge_os_pages) }, {-1, MI_OPTION(reserve_huge_os_pages_at) }, { MI_DEFAULT_RESERVE_OS_MEMORY, MI_OPTION(reserve_os_memory) }, { 0, MI_OPTION(deprecated_segment_cache) }, { 0, MI_OPTION(deprecated_page_reset) }, { 0, MI_OPTION(deprecated_abandoned_page_purge) },
{ 0, MI_OPTION(deprecated_segment_reset) }, { 1, MI_OPTION(deprecated_eager_commit_delay) },
{ 1000, MI_OPTION_LEGACY(purge_delay,reset_delay) }, { 0, MI_OPTION(use_numa_nodes) }, { 0, MI_OPTION_LEGACY(disallow_os_alloc,limit_os_alloc) }, { 100, MI_OPTION(os_tag) }, { 32, MI_OPTION(max_errors) }, { 32, MI_OPTION(max_warnings) }, { 10, MI_OPTION(deprecated_max_segment_reclaim)}, { 0, MI_OPTION(destroy_on_exit)}, { MI_DEFAULT_ARENA_RESERVE, MI_OPTION(arena_reserve) }, { 4, MI_OPTION(arena_purge_mult) }, { 1, MI_OPTION_LEGACY(deprecated_purge_extend_delay, decommit_extend_delay) },
{ MI_DEFAULT_DISALLOW_ARENA_ALLOC, MI_OPTION(disallow_arena_alloc) }, { 400, MI_OPTION(retry_on_oom) }, { 1, MI_OPTION(deprecated_visit_abandoned) },
{ 0, MI_OPTION(guarded_min) }, { MI_GiB, MI_OPTION(guarded_max) }, { 0, MI_OPTION(unsafe_guarded_precise) }, { MI_DEFAULT_GUARDED_SAMPLE_RATE, MI_OPTION(guarded_sample_rate)}, { 0, MI_OPTION(guarded_sample_seed)},
{ 10000, MI_OPTION(generic_collect) }, { 0, MI_OPTION_LEGACY(page_reclaim_on_free, abandoned_reclaim_on_free) }, { MI_DEFAULT_PAGE_FULL_RETAIN, MI_OPTION(page_full_retain) }, { 4, MI_OPTION(page_max_candidates) }, { 0, MI_OPTION(max_vabits) }, { MI_DEFAULT_PAGEMAP_COMMIT, MI_OPTION(pagemap_commit) }, { 0, MI_OPTION(page_commit_on_demand) }, { MI_DEFAULT_PAGE_MAX_RECLAIM, MI_OPTION(page_max_reclaim) }, { MI_DEFAULT_PAGE_CROSS_THREAD_MAX_RECLAIM, MI_OPTION(page_cross_thread_max_reclaim) }, { MI_DEFAULT_ALLOW_THP, MI_OPTION(allow_thp) }, { 0, MI_OPTION_LEGACY(arena_purge_min_size, minimal_purge_size) }, { MI_DEFAULT_ARENA_MAX_OBJECT_SIZE, MI_OPTION(arena_max_object_size) }, { 0, MI_OPTION(arena_is_numa_local) }, { MI_DEFAULT_STATS_MERGE_ON_COLLECT, MI_OPTION(stats_merge_on_collect) }, { MI_GiB, MI_OPTION(profile_alloc_interval) }, { 0, MI_OPTION(profile_inuse_interval) }, { 0, MI_OPTION(profile_time_interval) }, { 512*MI_KiB, MI_OPTION(profile_sample_rate) }, { MI_DEFAULT_STATS_MERGE_THRESHOLD, MI_OPTION(stats_merge_threshold) }, { MI_DEFAULT_ARENA_PURGE_IMMEDIATE_SIZE, MI_OPTION(arena_purge_immediate_size) },
};
static void mi_option_init(mi_option_t option, mi_option_state_t* state);
static const mi_option_desc_t* mi_option_desc(mi_option_t option) {
const mi_option_desc_t* desc = &mi_option_descs[option];
mi_assert(desc->option == option); return desc;
}
static mi_option_state_t* mi_option_state(mi_option_t option) {
mi_option_state_t* state = &_mi_process.options[option];
if mi_unlikely(state->init == MI_OPTION_UNINIT) {
state->value = mi_option_desc(option)->default_value;
state->init = MI_OPTION_PENDING;
}
return state;
}
static bool mi_option_has_size_in_kib(mi_option_t option) {
return (option == mi_option_reserve_os_memory || option == mi_option_arena_reserve ||
option == mi_option_arena_purge_min_size || option == mi_option_arena_purge_immediate_size ||
option == mi_option_arena_max_object_size
);
}
static bool mi_option_has_size_in_bytes(mi_option_t option) {
return (option == mi_option_stats_merge_threshold ||
option == mi_option_profile_alloc_interval || option == mi_option_profile_inuse_interval || option == mi_option_profile_sample_rate);
}
void _mi_options_init(void) {
for(int i = 0; i < _mi_option_last; i++ ) {
mi_option_t option = (mi_option_t)i;
long l = mi_option_get(option); MI_UNUSED(l); }
#if MI_GUARDED
if (mi_option_get(mi_option_guarded_sample_rate) > 0) {
if (mi_option_is_enabled(mi_option_allow_large_os_pages)) {
mi_option_disable(mi_option_allow_large_os_pages);
_mi_warning_message("option 'allow_large_os_pages' is disabled to allow for guarded objects\n");
}
}
#endif
}
void _mi_options_post_init(void) {
mi_add_stderr_output(); if (mi_option_is_enabled(mi_option_verbose)) { mi_options_print(); }
}
#define mi_stringifyx(str) #str
#define mi_stringify(str) mi_stringifyx(str)
mi_decl_export void mi_options_print_out(mi_output_fun* out, void* arg) mi_attr_noexcept
{
const int vermajor = MI_MALLOC_VERSION/10000;
const int verminor = (MI_MALLOC_VERSION%10000)/100;
const int verpatch = (MI_MALLOC_VERSION%100);
_mi_fprintf(out, arg, "v%i.%i.%i%s%s\n", vermajor, verminor, verpatch,
#if defined(MI_CMAKE_BUILD_TYPE)
", " mi_stringify(MI_CMAKE_BUILD_TYPE)
#else
""
#endif
,
#if defined(MI_GIT_DESCRIBE)
", git " mi_stringify(MI_GIT_DESCRIBE)
#else
""
#endif
);
for (int i = 0; i < _mi_option_last; i++) {
mi_option_t option = (mi_option_t)i;
long l = mi_option_get(option); _mi_fprintf(out, arg, "option '%s': %ld %s\n", mi_option_desc(option)->name, l, (mi_option_has_size_in_kib(option) ? "KiB" : (mi_option_has_size_in_bytes(option) ? "B" : "")));
}
#if MI_PAGE_META_IS_ALIGNED && MI_PAGE_META_SMALL_IS_ALIGNED
_mi_fprintf(out, arg, "free mode : (small) aligned, page size: %zu\n", sizeof(mi_page_t));
#elif MI_PAGE_META_IS_ALIGNED
_mi_fprintf(out, arg, "free mode : aligned, page size: %zu\n", sizeof(mi_page_t));
#elif MI_PAGE_META_SMALL_IS_ALIGNED
_mi_fprintf(out, arg, "free mode : small aligned + pagemap, page size: %zu\n", sizeof(mi_page_t));
#elif MI_FREE_IS_CHECKED
_mi_fprintf(out, arg, "free mode : checked, page size: %zu\n", sizeof(mi_page_t));
#else
_mi_fprintf(out, arg, "free mode : pagemap, page size: %zu\n", sizeof(mi_page_t));
#endif
#if MI_ENCODE_FREELIST
_mi_fprintf(out, arg, "free lists : encoded with %d key(s)\n", MI_PAGE_KEY_COUNT);
#endif
#if MI_GUARDED
_mi_fprintf(out, arg, "guarded mode: %s, rate=%ld\n", MI_SAMPLE==2 ? "fine-grained" : "enabled", mi_option_get(mi_option_guarded_sample_rate));
#endif
#if MI_PROFILE
_mi_fprintf(out, arg, "profiling : %s\n", MI_SAMPLE==2 ? "fine-grained" : "enabled");
#endif
#if MI_TSAN
_mi_fprintf(out, arg, "thread santizer enabled\n");
#endif
_mi_fprintf(out, arg, "mem tracking: %s\n", MI_TRACK_TOOL);
_mi_fprintf(out, arg, "debug level : %d\n", MI_DEBUG );
_mi_fprintf(out, arg, "secure level: %d\n", MI_SECURE );
_mi_fprintf(out, arg, "padding : %s\n", (MI_PADDING==0 ? "none" : (MI_PADDING==1 ? "enabled" : "byte precise")));
}
mi_decl_export void mi_options_print(void) mi_attr_noexcept {
mi_options_print_out(NULL, NULL);
}
long _mi_option_get_fast(mi_option_t option) {
mi_assert(option >= 0 && option < _mi_option_last);
return mi_option_state(option)->value;
}
mi_decl_nodiscard long mi_option_get(mi_option_t option) {
mi_assert(option >= 0 && option < _mi_option_last);
if (option < 0 || option >= _mi_option_last) return 0;
mi_option_state_t* state = &_mi_process.options[option];
if mi_unlikely(state->init < MI_OPTION_DEFAULTED) { state = mi_option_state(option);
mi_option_init(option, state);
}
return state->value;
}
mi_decl_nodiscard long mi_option_get_clamp(mi_option_t option, long min, long max) {
long x = mi_option_get(option);
return (x < min ? min : (x > max ? max : x));
}
mi_decl_nodiscard size_t mi_option_get_size(mi_option_t option) {
const long x = mi_option_get(option);
size_t size = (x < 0 ? 0 : (size_t)x);
if (mi_option_has_size_in_kib(option)) {
if (mi_mul_overflow(size, MI_KiB, &size)) {
size = MI_MAX_ALLOC_SIZE;
}
}
return size;
}
void mi_option_set(mi_option_t option, long value) {
mi_assert(option >= 0 && option < _mi_option_last);
if (option < 0 || option >= _mi_option_last) return;
mi_option_state_t* const state = &_mi_process.options[option];
state->value = value;
state->init = MI_OPTION_INITIALIZED;
if (option == mi_option_guarded_min && mi_option_state(mi_option_guarded_max)->value < value) {
mi_option_set(mi_option_guarded_max, value);
}
else if (option == mi_option_guarded_max && mi_option_state(mi_option_guarded_min)->value > value) {
mi_option_set(mi_option_guarded_min, value);
}
}
void mi_option_set_default(mi_option_t option, long value) {
mi_assert(option >= 0 && option < _mi_option_last);
if (option < 0 || option >= _mi_option_last) return;
mi_option_state_t* const state = mi_option_state(option);
if (state->init != MI_OPTION_INITIALIZED) {
state->value = value;
}
}
mi_decl_nodiscard bool mi_option_is_enabled(mi_option_t option) {
return (mi_option_get(option) != 0);
}
void mi_option_set_enabled(mi_option_t option, bool enable) {
mi_option_set(option, (enable ? 1 : 0));
}
void mi_option_set_enabled_default(mi_option_t option, bool enable) {
mi_option_set_default(option, (enable ? 1 : 0));
}
void mi_option_enable(mi_option_t option) {
mi_option_set_enabled(option,true);
}
void mi_option_disable(mi_option_t option) {
mi_option_set_enabled(option,false);
}
static void mi_cdecl mi_out_stderr(const char* msg, void* arg) {
MI_UNUSED(arg);
if (msg != NULL && msg[0] != 0) {
_mi_prim_out_stderr(msg);
}
}
static mi_lock_t out_buf_lock = MI_LOCK_INITIALIZER;
static void mi_cdecl mi_out_buf(const char* msg, void* arg) {
MI_UNUSED(arg);
if (msg==NULL) return;
if (mi_atomic_load_acquire(&_mi_process.output_buf_len)>=MI_MAX_DELAY_OUTPUT) return;
size_t n = _mi_strlen(msg);
if (n==0 || n >= MI_MAX_DELAY_OUTPUT) return;
mi_lock(&out_buf_lock) {
const size_t start = mi_atomic_add_acq_rel(&_mi_process.output_buf_len, n);
if (start < MI_MAX_DELAY_OUTPUT) {
if (start+n >= MI_MAX_DELAY_OUTPUT) {
n = MI_MAX_DELAY_OUTPUT-start-1;
}
mi_memcpy(&_mi_process.output_buf[start], msg, n);
}
}
}
static void mi_out_buf_flush(mi_output_fun* out, bool no_more_buf, void* arg) {
if (out==NULL) return;
mi_lock(&out_buf_lock) {
size_t count = mi_atomic_add_acq_rel(&_mi_process.output_buf_len, (no_more_buf ? MI_MAX_DELAY_OUTPUT : 1));
if (count>MI_MAX_DELAY_OUTPUT) count = MI_MAX_DELAY_OUTPUT;
_mi_process.output_buf[count] = 0;
out(_mi_process.output_buf,arg);
if (!no_more_buf) {
_mi_process.output_buf[count] = '\n'; }
}
}
static void mi_cdecl mi_out_buf_stderr(const char* msg, void* arg) {
mi_out_stderr(msg,arg);
mi_out_buf(msg,arg);
}
static mi_output_fun* mi_out_get_default(void** parg) {
mi_output_fun* const out = (mi_output_fun*)mi_atomic_load_ptr_acquire(void,&_mi_process.out_default);
if (parg != NULL) { *parg = mi_atomic_load_ptr_acquire(void,&_mi_process.out_arg); }
return (out == NULL ? &mi_out_buf : out);
}
void mi_register_output(mi_output_fun* out, void* arg) mi_attr_noexcept {
mi_atomic_store_ptr_release(void,&_mi_process.out_default, (void*)(out == NULL ? &mi_out_stderr : out)); mi_atomic_store_ptr_release(void,&_mi_process.out_arg, arg);
if (out!=NULL) { mi_out_buf_flush(out,true,arg); } }
static void mi_add_stderr_output(void) {
mi_assert_internal(_mi_process.out_default == NULL);
mi_out_buf_flush(&mi_out_stderr, false, NULL); mi_atomic_store_ptr_release(void,&_mi_process.out_default,(void*)&mi_out_buf_stderr); mi_atomic_store_ptr_release(void,&_mi_process.out_arg,NULL);
}
static mi_decl_noinline bool mi_recurse_enter_prim(void) {
return true;
}
static mi_decl_noinline void mi_recurse_exit_prim(void) {
}
static bool mi_recurse_enter(void) {
#if defined(__APPLE__) || defined(__ANDROID__) || defined(MI_TLS_RECURSE_GUARD)
if (_mi_preloading()) return false;
#endif
return mi_recurse_enter_prim();
}
static void mi_recurse_exit(void) {
#if defined(__APPLE__) || defined(__ANDROID__) || defined(MI_TLS_RECURSE_GUARD)
if (_mi_preloading()) return;
#endif
mi_recurse_exit_prim();
}
void _mi_fputs(mi_output_fun* out, void* arg, const char* prefix, const char* message) {
if (out==NULL || (void*)out==(void*)stdout || (void*)out==(void*)stderr) { if (!mi_recurse_enter()) return;
out = mi_out_get_default(&arg);
if (prefix != NULL) out(prefix, arg);
out(message, arg);
mi_recurse_exit();
}
else {
if (prefix != NULL) out(prefix, arg);
out(message, arg);
}
}
static void mi_vfprintf( mi_output_fun* out, void* arg, const char* prefix, const char* fmt, va_list args ) {
char buf[992];
if (fmt==NULL) return;
if (!mi_recurse_enter()) return;
_mi_vsnprintf(buf, sizeof(buf)-1, fmt, args);
mi_recurse_exit();
_mi_fputs(out,arg,prefix,buf);
}
void _mi_fprintf( mi_output_fun* out, void* arg, const char* fmt, ... ) {
va_list args;
va_start(args,fmt);
mi_vfprintf(out,arg,NULL,fmt,args);
va_end(args);
}
static void mi_vfprintf_thread(mi_output_fun* out, void* arg, const char* prefix, const char* fmt, va_list args) {
if (prefix != NULL && _mi_strnlen(prefix,33) <= 32) { char tprefix[64];
_mi_snprintf(tprefix, sizeof(tprefix), "%sthread 0x%tx: ", prefix, (size_t)_mi_thread_id());
mi_vfprintf(out, arg, tprefix, fmt, args);
}
else {
mi_vfprintf(out, arg, prefix, fmt, args);
}
}
void _mi_raw_message(const char* fmt, ...) {
va_list args;
va_start(args, fmt);
mi_vfprintf(NULL, NULL, NULL, fmt, args);
va_end(args);
}
void _mi_trace_message(const char* fmt, ...) {
if (mi_option_get(mi_option_verbose) <= 1) return; va_list args;
va_start(args, fmt);
mi_vfprintf_thread(NULL, NULL, "mimalloc: ", fmt, args);
va_end(args);
}
void _mi_verbose_message(const char* fmt, ...) {
if (!mi_option_is_enabled(mi_option_verbose)) return;
va_list args;
va_start(args,fmt);
mi_vfprintf(NULL, NULL, "mimalloc: ", fmt, args);
va_end(args);
}
static void mi_show_error_message(const char* fmt, va_list args) {
if (!mi_option_is_enabled(mi_option_verbose)) {
if (!mi_option_is_enabled(mi_option_show_errors)) return;
const long max_errors = mi_option_get(mi_option_max_errors);
if (max_errors >= 0 && (long)mi_atomic_increment_acq_rel(&_mi_process.error_count) > max_errors) return;
}
mi_vfprintf_thread(NULL, NULL, "mimalloc: error: ", fmt, args);
}
void _mi_warning_message(const char* fmt, ...) {
if (!mi_option_is_enabled(mi_option_verbose)) {
if (!mi_option_is_enabled(mi_option_show_errors)) return;
const long max_warnings = mi_option_get(mi_option_max_warnings);
if (max_warnings >= 0 && (long)mi_atomic_increment_acq_rel(&_mi_process.warning_count) > max_warnings) return;
}
va_list args;
va_start(args,fmt);
mi_vfprintf_thread(NULL, NULL, "mimalloc: warning: ", fmt, args);
va_end(args);
}
#if MI_DEBUG
mi_decl_noreturn mi_decl_cold void _mi_assert_fail(const char* assertion, const char* fname, unsigned line, const char* func ) mi_attr_noexcept {
_mi_fprintf(NULL, NULL, "mimalloc: assertion failed: at \"%s\":%u, %s\n assertion: \"%s\"\n", fname, line, (func==NULL?"":func), assertion);
if (mi_atomic_load_ptr_acquire(void,&_mi_process.out_default) == NULL) { mi_out_buf_flush(&mi_out_stderr, true, NULL); }
abort();
}
#endif
static void mi_error_default(int err) {
MI_UNUSED(err);
#if (MI_DEBUG>0)
if (err==EFAULT) {
#ifdef _MSC_VER
__debugbreak();
#endif
abort();
}
#endif
#if MI_SECURE
if (err==EFAULT) { abort();
}
#endif
#if defined(MI_XMALLOC)
if (err==ENOMEM || err==EOVERFLOW || err==EINVAL) { abort();
}
#endif
if (errno==0) {
errno = (err==EINVAL ? EINVAL : ENOMEM );
}
}
void mi_register_error(mi_error_fun* fun, void* arg) {
mi_atomic_store_ptr_release(void,&_mi_process.error_arg, arg);
mi_atomic_store_ptr_release(void,&_mi_process.error_handler, (void*)fun); }
void _mi_error_message(int err, const char* fmt, ...) {
va_list args;
va_start(args, fmt);
mi_show_error_message(fmt, args);
va_end(args);
mi_error_fun* const handler = (mi_error_fun*)mi_atomic_load_ptr_acquire(void,&_mi_process.error_handler);
if (handler != NULL) {
handler(err, mi_atomic_load_ptr_acquire(void,&_mi_process.error_arg));
}
else {
mi_error_default(err);
}
}
mi_decl_noinline mi_block_t* _mi_block_next_is_corrupted(const mi_page_t* page, const mi_block_t* block, const mi_block_t* next) {
_mi_error_message(EFAULT, "corrupted free list entry of size %zub at %p: value 0x%zx\n", mi_page_block_size(page), block, (size_t)mi_addr(next));
return NULL;
}
static void mi_option_init(mi_option_t option, mi_option_state_t* state) {
const mi_option_desc_t* const desc = mi_option_desc(option);
char s[64 + 1];
char buf[64+1];
_mi_strlcpy(buf, "mimalloc_", sizeof(buf));
_mi_strlcat(buf, desc->name, sizeof(buf));
int err = _mi_getenv(buf, s, sizeof(s));
if (err==ENOENT && desc->legacy_name != NULL) {
_mi_strlcpy(buf, "mimalloc_", sizeof(buf));
_mi_strlcat(buf, desc->legacy_name, sizeof(buf));
err = _mi_getenv(buf, s, sizeof(s));
if (err==0) {
_mi_warning_message("environment option \"mimalloc_%s\" is deprecated -- use \"mimalloc_%s\" instead.\n", desc->legacy_name, desc->name);
}
}
if (err==0) {
size_t len = _mi_strnlen(s, sizeof(buf) - 1);
for (size_t i = 0; i < len; i++) {
buf[i] = _mi_toupper(s[i]);
}
buf[len] = 0;
if (buf[0] == 0 || _mi_streq(buf,"1") || _mi_streq(buf,"TRUE") || _mi_streq(buf,"YES") || _mi_streq(buf,"ON")) {
state->value = 1;
state->init = MI_OPTION_INITIALIZED;
}
else if (_mi_streq(buf,"0") || _mi_streq(buf,"FALSE") || _mi_streq(buf,"NO") || _mi_streq(buf,"OFF")) {
state->value = 0;
state->init = MI_OPTION_INITIALIZED;
}
else {
const char* end = buf;
long value = 0;
const bool ok = _mi_strntol(buf, sizeof(buf), &end, &value);
if (ok && (mi_option_has_size_in_kib(option) || mi_option_has_size_in_bytes(option))) {
size_t size = (value < 0 ? 0 : (size_t)value);
bool overflow = false;
if (*end == 'K') { overflow = mi_mul_overflow(size,MI_KiB,&size); end++; }
#if MI_SIZE_SIZE >= 4
else if (*end == 'M') { overflow = mi_mul_overflow(size,MI_MiB,&size); end++; }
else if (*end == 'G') { overflow = mi_mul_overflow(size,MI_GiB,&size); end++; }
#endif
#if MI_SIZE_SIZE >= 8
else if (*end == 'T') { overflow = mi_mul_overflow(size,MI_GiB * MI_KiB,&size); end++; }
#endif
if (end[0] == 'I' && end[1] == 'B') { end += 2; } else if (*end == 'B') { end++; } if (overflow || size > MI_MAX_ALLOC_SIZE) { size = MI_MAX_ALLOC_SIZE; }
if (mi_option_has_size_in_kib(option)) {
size = (size + MI_KiB - 1) / MI_KiB; }
value = (size > LONG_MAX ? LONG_MAX : (long)size);
}
if (ok && *end == 0) {
mi_option_set(option, value);
}
else {
state->init = MI_OPTION_DEFAULTED;
if (option == mi_option_verbose && state->value == 0) {
state->value = 1;
_mi_warning_message("environment option mimalloc_%s has an invalid value.\n", desc->name);
state->value = 0;
}
else {
_mi_warning_message("environment option mimalloc_%s has an invalid value.\n", desc->name);
}
}
}
mi_assert_internal(state->init >= MI_OPTION_DEFAULTED);
}
else if (err==ENOENT) {
state->init = MI_OPTION_DEFAULTED;
}
}