Restoring authorship annotation for <bugaevskiy@yandex-team.ru>. Commit 2 of 2.

1 files changed, 325 insertions, 325 deletions

diff --git a/contrib/libs/jemalloc/src/zone.c b/contrib/libs/jemalloc/src/zone.c
index 123a7b038f..23dfdd04a9 100644
--- a/contrib/libs/jemalloc/src/zone.c
+++ b/contrib/libs/jemalloc/src/zone.c
@@ -1,83 +1,83 @@
-#include "jemalloc/internal/jemalloc_preamble.h" 
-#include "jemalloc/internal/jemalloc_internal_includes.h" 
- 
-#include "jemalloc/internal/assert.h" 
- 
+#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); 
- 
+/* 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. 
+ * 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)
@@ -86,15 +86,15 @@ 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; 
+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 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);
@@ -104,25 +104,25 @@ 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 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 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); 
+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);
 
 /******************************************************************************/
 /*
@@ -130,7 +130,7 @@ static void	zone_reinit_lock(malloc_zone_t *zone);
  */
 
 static size_t
-zone_size(malloc_zone_t *zone, const void *ptr) { 
+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
@@ -138,33 +138,33 @@ zone_size(malloc_zone_t *zone, const void *ptr) {
 	 * 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. 
+	 * reside within a mapped extent before determining size.
 	 */
-	return ivsalloc(tsdn_fetch(), ptr); 
+	return ivsalloc(tsdn_fetch(), ptr);
 }
 
 static void *
-zone_malloc(malloc_zone_t *zone, size_t size) { 
-	return je_malloc(size); 
+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); 
+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) { 
+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; 
+	return ret;
 }
 
 static void
-zone_free(malloc_zone_t *zone, void *ptr) { 
-	if (ivsalloc(tsdn_fetch(), ptr) != 0) { 
+zone_free(malloc_zone_t *zone, void *ptr) {
+	if (ivsalloc(tsdn_fetch(), ptr) != 0) {
 		je_free(ptr);
 		return;
 	}
@@ -173,30 +173,30 @@ zone_free(malloc_zone_t *zone, void *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); 
-	} 
+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); 
+	return realloc(ptr, size);
 }
 
 static void *
-zone_memalign(malloc_zone_t *zone, size_t alignment, size_t size) { 
+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; 
+	return ret;
 }
 
 static void
-zone_free_definite_size(malloc_zone_t *zone, void *ptr, size_t size) { 
-	size_t alloc_size; 
+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); 
+	alloc_size = ivsalloc(tsdn_fetch(), ptr);
+	if (alloc_size != 0) {
+		assert(alloc_size == size);
 		je_free(ptr);
 		return;
 	}
@@ -204,170 +204,170 @@ zone_free_definite_size(malloc_zone_t *zone, void *ptr, size_t size) {
 	free(ptr);
 }
 
-static void 
-zone_destroy(malloc_zone_t *zone) { 
+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 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; 
-} 
+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) { 
+static size_t
+zone_good_size(malloc_zone_t *zone, size_t size) {
+	if (size == 0) {
 		size = 1;
-	} 
-	return sz_s2u(size); 
+	}
+	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 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(); 
+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_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; 
+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) { 
+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;
 
@@ -377,72 +377,72 @@ zone_default_get(void) {
 	 * 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. 
+	 * 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. 
-		 */ 
+	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) { 
+	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); 
-} 
- 
+/* 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) { 
+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) { 
+	default_zone = zone_default_get();
+	if (!default_zone->zone_name || strcmp(default_zone->zone_name,
+	    "DefaultMallocZone") != 0) {
 		return;
 	}
 
@@ -451,19 +451,19 @@ zone_register(void) {
 	 * 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 
+	 * 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(); 
+	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); 
+	zone_init();
+	malloc_zone_register(&jemalloc_zone);
 
-	/* Promote the custom zone to be default. */ 
-	zone_promote(); 
+	/* Promote the custom zone to be default. */
+	zone_promote();
 }