#include "jemalloc/internal/jemalloc_preamble.h"

#include "jemalloc/internal/jemalloc_internal_includes.h"

#include "jemalloc/internal/assert.h"

#ifndef JEMALLOC_ZONE

#  error "This source file is for zones on Darwin (OS X)."

#endif

/* Definitions of the following structs in malloc/malloc.h might be too old

 * for the built binary to run on newer versions of OSX. So use the newest

 * possible version of those structs.

 */

typedef struct _malloc_zone_t {

	void *reserved1;

	void *reserved2;

	size_t (*size)(struct _malloc_zone_t *, const void *);

	void *(*malloc)(struct _malloc_zone_t *, size_t);

	void *(*calloc)(struct _malloc_zone_t *, size_t, size_t);

	void *(*valloc)(struct _malloc_zone_t *, size_t);

	void (*free)(struct _malloc_zone_t *, void *);

	void *(*realloc)(struct _malloc_zone_t *, void *, size_t);

	void (*destroy)(struct _malloc_zone_t *);

	const char *zone_name;

	unsigned (*batch_malloc)(struct _malloc_zone_t *, size_t, void **, unsigned);

	void (*batch_free)(struct _malloc_zone_t *, void **, unsigned);

	struct malloc_introspection_t *introspect;

	unsigned version;

	void *(*memalign)(struct _malloc_zone_t *, size_t, size_t);

	void (*free_definite_size)(struct _malloc_zone_t *, void *, size_t);

	size_t (*pressure_relief)(struct _malloc_zone_t *, size_t);

} malloc_zone_t;

typedef struct {

	vm_address_t address;

	vm_size_t size;

} vm_range_t;

typedef struct malloc_statistics_t {

	unsigned blocks_in_use;

	size_t size_in_use;

	size_t max_size_in_use;

	size_t size_allocated;

} malloc_statistics_t;

typedef kern_return_t memory_reader_t(task_t, vm_address_t, vm_size_t, void **);

typedef void vm_range_recorder_t(task_t, void *, unsigned type, vm_range_t *, unsigned);

typedef struct malloc_introspection_t {

	kern_return_t (*enumerator)(task_t, void *, unsigned, vm_address_t, memory_reader_t, vm_range_recorder_t);

	size_t (*good_size)(malloc_zone_t *, size_t);

	boolean_t (*check)(malloc_zone_t *);

	void (*print)(malloc_zone_t *, boolean_t);

	void (*log)(malloc_zone_t *, void *);

	void (*force_lock)(malloc_zone_t *);

	void (*force_unlock)(malloc_zone_t *);

	void (*statistics)(malloc_zone_t *, malloc_statistics_t *);

	boolean_t (*zone_locked)(malloc_zone_t *);

	boolean_t (*enable_discharge_checking)(malloc_zone_t *);

	boolean_t (*disable_discharge_checking)(malloc_zone_t *);

	void (*discharge)(malloc_zone_t *, void *);

#ifdef __BLOCKS__

	void (*enumerate_discharged_pointers)(malloc_zone_t *, void (^)(void *, void *));

#else

	void *enumerate_unavailable_without_blocks;

#endif

	void (*reinit_lock)(malloc_zone_t *);

} malloc_introspection_t;

extern kern_return_t malloc_get_all_zones(task_t, memory_reader_t, vm_address_t **, unsigned *);

extern malloc_zone_t *malloc_default_zone(void);

extern void malloc_zone_register(malloc_zone_t *zone);

extern void malloc_zone_unregister(malloc_zone_t *zone);

/*

 * The malloc_default_purgeable_zone() function is only available on >= 10.6.

 * We need to check whether it is present at runtime, thus the weak_import.

 */

extern malloc_zone_t *malloc_default_purgeable_zone(void)

JEMALLOC_ATTR(weak_import);

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

/* Data. */

static malloc_zone_t *default_zone, *purgeable_zone;

static malloc_zone_t jemalloc_zone;

static struct malloc_introspection_t jemalloc_zone_introspect;

static pid_t zone_force_lock_pid = -1;

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

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

static size_t	zone_size(malloc_zone_t *zone, const void *ptr);

static void	*zone_malloc(malloc_zone_t *zone, size_t size);

static void	*zone_calloc(malloc_zone_t *zone, size_t num, size_t size);

static void	*zone_valloc(malloc_zone_t *zone, size_t size);

static void	zone_free(malloc_zone_t *zone, void *ptr);

static void	*zone_realloc(malloc_zone_t *zone, void *ptr, size_t size);

static void	*zone_memalign(malloc_zone_t *zone, size_t alignment,

    size_t size);

static void	zone_free_definite_size(malloc_zone_t *zone, void *ptr,

    size_t size);

static void	zone_destroy(malloc_zone_t *zone);

static unsigned	zone_batch_malloc(struct _malloc_zone_t *zone, size_t size,

    void **results, unsigned num_requested);

static void	zone_batch_free(struct _malloc_zone_t *zone,

    void **to_be_freed, unsigned num_to_be_freed);

static size_t	zone_pressure_relief(struct _malloc_zone_t *zone, size_t goal);

static size_t	zone_good_size(malloc_zone_t *zone, size_t size);

static kern_return_t	zone_enumerator(task_t task, void *data, unsigned type_mask,

    vm_address_t zone_address, memory_reader_t reader,

    vm_range_recorder_t recorder);

static boolean_t	zone_check(malloc_zone_t *zone);

static void	zone_print(malloc_zone_t *zone, boolean_t verbose);

static void	zone_log(malloc_zone_t *zone, void *address);

static void	zone_force_lock(malloc_zone_t *zone);

static void	zone_force_unlock(malloc_zone_t *zone);

static void	zone_statistics(malloc_zone_t *zone,

    malloc_statistics_t *stats);

static boolean_t	zone_locked(malloc_zone_t *zone);

static void	zone_reinit_lock(malloc_zone_t *zone);

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

/*

 * Functions.

 */

static size_t

zone_size(malloc_zone_t *zone, const void *ptr) {

	/*

	 * There appear to be places within Darwin (such as setenv(3)) that

	 * cause calls to this function with pointers that *no* zone owns.  If

	 * we knew that all pointers were owned by *some* zone, we could split

	 * our zone into two parts, and use one as the default allocator and

	 * the other as the default deallocator/reallocator.  Since that will

	 * not work in practice, we must check all pointers to assure that they

	 * reside within a mapped extent before determining size.

	 */

	return ivsalloc(tsdn_fetch(), ptr);

}

static void *

zone_malloc(malloc_zone_t *zone, size_t size) {

	return je_malloc(size);

}

static void *

zone_calloc(malloc_zone_t *zone, size_t num, size_t size) {

	return je_calloc(num, size);

}

static void *

zone_valloc(malloc_zone_t *zone, size_t size) {

	void *ret = NULL; /* Assignment avoids useless compiler warning. */

	je_posix_memalign(&ret, PAGE, size);

	return ret;

}

static void

zone_free(malloc_zone_t *zone, void *ptr) {

	if (ivsalloc(tsdn_fetch(), ptr) != 0) {

		je_free(ptr);

		return;

	}

	free(ptr);

}

static void *

zone_realloc(malloc_zone_t *zone, void *ptr, size_t size) {

	if (ivsalloc(tsdn_fetch(), ptr) != 0) {

		return je_realloc(ptr, size);

	}

	return realloc(ptr, size);

}

static void *

zone_memalign(malloc_zone_t *zone, size_t alignment, size_t size) {

	void *ret = NULL; /* Assignment avoids useless compiler warning. */

	je_posix_memalign(&ret, alignment, size);

	return ret;

}

static void

zone_free_definite_size(malloc_zone_t *zone, void *ptr, size_t size) {

	size_t alloc_size;

	alloc_size = ivsalloc(tsdn_fetch(), ptr);

	if (alloc_size != 0) {

		assert(alloc_size == size);

		je_free(ptr);

		return;

	}

	free(ptr);

}

static void

zone_destroy(malloc_zone_t *zone) {

	/* This function should never be called. */

	not_reached();

}

static unsigned

zone_batch_malloc(struct _malloc_zone_t *zone, size_t size, void **results,

    unsigned num_requested) {

	unsigned i;

	for (i = 0; i < num_requested; i++) {

		results[i] = je_malloc(size);

		if (!results[i])

			break;

	}

	return i;

}

static void

zone_batch_free(struct _malloc_zone_t *zone, void **to_be_freed,

    unsigned num_to_be_freed) {

	unsigned i;

	for (i = 0; i < num_to_be_freed; i++) {

		zone_free(zone, to_be_freed[i]);

		to_be_freed[i] = NULL;

	}

}

static size_t

zone_pressure_relief(struct _malloc_zone_t *zone, size_t goal) {

	return 0;

}

static size_t

zone_good_size(malloc_zone_t *zone, size_t size) {

	if (size == 0) {

		size = 1;

	}

	return sz_s2u(size);

}

static kern_return_t

zone_enumerator(task_t task, void *data, unsigned type_mask,

    vm_address_t zone_address, memory_reader_t reader,

    vm_range_recorder_t recorder) {

	return KERN_SUCCESS;

}

static boolean_t

zone_check(malloc_zone_t *zone) {

	return true;

}

static void

zone_print(malloc_zone_t *zone, boolean_t verbose) {

}

static void

zone_log(malloc_zone_t *zone, void *address) {

}

static void

zone_force_lock(malloc_zone_t *zone) {

	if (isthreaded) {

		/*

		 * See the note in zone_force_unlock, below, to see why we need

		 * this.

		 */

		assert(zone_force_lock_pid == -1);

		zone_force_lock_pid = getpid();

		jemalloc_prefork();

	}

}

static void

zone_force_unlock(malloc_zone_t *zone) {

	/*

	 * zone_force_lock and zone_force_unlock are the entry points to the

	 * forking machinery on OS X.  The tricky thing is, the child is not

	 * allowed to unlock mutexes locked in the parent, even if owned by the

	 * forking thread (and the mutex type we use in OS X will fail an assert

	 * if we try).  In the child, we can get away with reinitializing all

	 * the mutexes, which has the effect of unlocking them.  In the parent,

	 * doing this would mean we wouldn't wake any waiters blocked on the

	 * mutexes we unlock.  So, we record the pid of the current thread in

	 * zone_force_lock, and use that to detect if we're in the parent or

	 * child here, to decide which unlock logic we need.

	 */

	if (isthreaded) {

		assert(zone_force_lock_pid != -1);

		if (getpid() == zone_force_lock_pid) {

			jemalloc_postfork_parent();

		} else {

			jemalloc_postfork_child();

		}

		zone_force_lock_pid = -1;

	}

}

static void

zone_statistics(malloc_zone_t *zone, malloc_statistics_t *stats) {

	/* We make no effort to actually fill the values */

	stats->blocks_in_use = 0;

	stats->size_in_use = 0;

	stats->max_size_in_use = 0;

	stats->size_allocated = 0;

}

static boolean_t

zone_locked(malloc_zone_t *zone) {

	/* Pretend no lock is being held */

	return false;

}

static void

zone_reinit_lock(malloc_zone_t *zone) {

	/* As of OSX 10.12, this function is only used when force_unlock would

	 * be used if the zone version were < 9. So just use force_unlock. */

	zone_force_unlock(zone);

}

static void

zone_init(void) {

	jemalloc_zone.size = zone_size;

	jemalloc_zone.malloc = zone_malloc;

	jemalloc_zone.calloc = zone_calloc;

	jemalloc_zone.valloc = zone_valloc;

	jemalloc_zone.free = zone_free;

	jemalloc_zone.realloc = zone_realloc;

	jemalloc_zone.destroy = zone_destroy;

	jemalloc_zone.zone_name = "jemalloc_zone";

	jemalloc_zone.batch_malloc = zone_batch_malloc;

	jemalloc_zone.batch_free = zone_batch_free;

	jemalloc_zone.introspect = &jemalloc_zone_introspect;

	jemalloc_zone.version = 9;

	jemalloc_zone.memalign = zone_memalign;

	jemalloc_zone.free_definite_size = zone_free_definite_size;

	jemalloc_zone.pressure_relief = zone_pressure_relief;

	jemalloc_zone_introspect.enumerator = zone_enumerator;

	jemalloc_zone_introspect.good_size = zone_good_size;

	jemalloc_zone_introspect.check = zone_check;

	jemalloc_zone_introspect.print = zone_print;

	jemalloc_zone_introspect.log = zone_log;

	jemalloc_zone_introspect.force_lock = zone_force_lock;

	jemalloc_zone_introspect.force_unlock = zone_force_unlock;

	jemalloc_zone_introspect.statistics = zone_statistics;

	jemalloc_zone_introspect.zone_locked = zone_locked;

	jemalloc_zone_introspect.enable_discharge_checking = NULL;

	jemalloc_zone_introspect.disable_discharge_checking = NULL;

	jemalloc_zone_introspect.discharge = NULL;

#ifdef __BLOCKS__

	jemalloc_zone_introspect.enumerate_discharged_pointers = NULL;

#else

	jemalloc_zone_introspect.enumerate_unavailable_without_blocks = NULL;

#endif

	jemalloc_zone_introspect.reinit_lock = zone_reinit_lock;

}

static malloc_zone_t *

zone_default_get(void) {

	malloc_zone_t **zones = NULL;

	unsigned int num_zones = 0;

	/*

	 * On OSX 10.12, malloc_default_zone returns a special zone that is not

	 * present in the list of registered zones. That zone uses a "lite zone"

	 * if one is present (apparently enabled when malloc stack logging is

	 * enabled), or the first registered zone otherwise. In practice this

	 * means unless malloc stack logging is enabled, the first registered

	 * zone is the default.  So get the list of zones to get the first one,

	 * instead of relying on malloc_default_zone.

	 */

	if (KERN_SUCCESS != malloc_get_all_zones(0, NULL,

	    (vm_address_t**)&zones, &num_zones)) {

		/*

		 * Reset the value in case the failure happened after it was

		 * set.

		 */

		num_zones = 0;

	}

	if (num_zones) {

		return zones[0];

	}

	return malloc_default_zone();

}

/* As written, this function can only promote jemalloc_zone. */

static void

zone_promote(void) {

	malloc_zone_t *zone;

	do {

		/*

		 * Unregister and reregister the default zone.  On OSX >= 10.6,

		 * unregistering takes the last registered zone and places it

		 * at the location of the specified zone.  Unregistering the

		 * default zone thus makes the last registered one the default.

		 * On OSX < 10.6, unregistering shifts all registered zones.

		 * The first registered zone then becomes the default.

		 */

		malloc_zone_unregister(default_zone);

		malloc_zone_register(default_zone);

		/*

		 * On OSX 10.6, having the default purgeable zone appear before

		 * the default zone makes some things crash because it thinks it

		 * owns the default zone allocated pointers.  We thus

		 * unregister/re-register it in order to ensure it's always

		 * after the default zone.  On OSX < 10.6, there is no purgeable

		 * zone, so this does nothing.  On OSX >= 10.6, unregistering

		 * replaces the purgeable zone with the last registered zone

		 * above, i.e. the default zone.  Registering it again then puts

		 * it at the end, obviously after the default zone.

		 */

		if (purgeable_zone != NULL) {

			malloc_zone_unregister(purgeable_zone);

			malloc_zone_register(purgeable_zone);

		}

		zone = zone_default_get();

	} while (zone != &jemalloc_zone);

}

JEMALLOC_ATTR(constructor)

void

zone_register(void) {

	/*

	 * If something else replaced the system default zone allocator, don't

	 * register jemalloc's.

	 */

	default_zone = zone_default_get();

	if (!default_zone->zone_name || strcmp(default_zone->zone_name,

	    "DefaultMallocZone") != 0) {

		return;

	}

	/*

	 * The default purgeable zone is created lazily by OSX's libc.  It uses

	 * the default zone when it is created for "small" allocations

	 * (< 15 KiB), but assumes the default zone is a scalable_zone.  This

	 * obviously fails when the default zone is the jemalloc zone, so

	 * malloc_default_purgeable_zone() is called beforehand so that the

	 * default purgeable zone is created when the default zone is still

	 * a scalable_zone.  As purgeable zones only exist on >= 10.6, we need

	 * to check for the existence of malloc_default_purgeable_zone() at

	 * run time.

	 */

	purgeable_zone = (malloc_default_purgeable_zone == NULL) ? NULL :

	    malloc_default_purgeable_zone();

	/* Register the custom zone.  At this point it won't be the default. */

	zone_init();

	malloc_zone_register(&jemalloc_zone);

	/* Promote the custom zone to be default. */

	zone_promote();

}