Remove quarantine support.

24 files changed, 51 insertions, 519 deletions

diff --git a/INSTALL b/INSTALL
index 36306fe..4f57b36 100644
--- a/INSTALL
+++ b/INSTALL
@@ -165,9 +165,9 @@ any of the following arguments (not a definitive list) to 'configure':
     normal jemalloc operation.
 
 --disable-fill
-    Disable support for junk/zero filling of memory, quarantine, and redzones.
-    See the "opt.junk", "opt.zero", "opt.quarantine", and "opt.redzone" option
-    documentation for usage details.
+    Disable support for junk/zero filling of memory and redzones.  See the
+    "opt.junk", "opt.zero", and "opt.redzone" option documentation for usage
+    details.
 
 --disable-zone-allocator
     Disable zone allocator for Darwin.  This means jemalloc won't be hooked as
diff --git a/Makefile.in b/Makefile.in
index 34facf4..8cd6af9 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -95,7 +95,6 @@ C_SRCS := $(srcroot)src/jemalloc.c \
 	$(srcroot)src/pages.c \
 	$(srcroot)src/prng.c \
 	$(srcroot)src/prof.c \
-	$(srcroot)src/quarantine.c \
 	$(srcroot)src/rtree.c \
 	$(srcroot)src/stats.c \
 	$(srcroot)src/tcache.c \
@@ -157,7 +156,6 @@ TESTS_UNIT := \
 	$(srcroot)test/unit/prof_thread_name.c \
 	$(srcroot)test/unit/ql.c \
 	$(srcroot)test/unit/qr.c \
-	$(srcroot)test/unit/quarantine.c \
 	$(srcroot)test/unit/rb.c \
 	$(srcroot)test/unit/rtree.c \
 	$(srcroot)test/unit/run_quantize.c \
diff --git a/configure.ac b/configure.ac
index df5cf25..92192d4 100644
--- a/configure.ac
+++ b/configure.ac
@@ -946,7 +946,7 @@ fi
 dnl Support the junk/zero filling option by default.
 AC_ARG_ENABLE([fill],
   [AS_HELP_STRING([--disable-fill],
-                  [Disable support for junk/zero filling, quarantine, and redzones])],
+                  [Disable support for junk/zero filling and redzones])],
 [if test "x$enable_fill" = "xno" ; then
   enable_fill="0"
 else
diff --git a/doc/jemalloc.xml.in b/doc/jemalloc.xml.in
index 2f8f150..7ed0333 100644
--- a/doc/jemalloc.xml.in
+++ b/doc/jemalloc.xml.in
@@ -1040,23 +1040,6 @@ for (i = 0; i < nbins; i++) {
         default.</para></listitem>
       </varlistentry>
 
-      <varlistentry id="opt.quarantine">
-        <term>
-          <mallctl>opt.quarantine</mallctl>
-          (<type>size_t</type>)
-          <literal>r-</literal>
-          [<option>--enable-fill</option>]
-        </term>
-        <listitem><para>Per thread quarantine size in bytes.  If non-zero, each
-        thread maintains a FIFO object quarantine that stores up to the
-        specified number of bytes of memory.  The quarantined memory is not
-        freed until it is released from quarantine, though it is immediately
-        junk-filled if the <link
-        linkend="opt.junk"><mallctl>opt.junk</mallctl></link> option is enabled.
-        This is intended for debugging and will impact performance negatively.
-        The default quarantine size is 0.</para></listitem>
-      </varlistentry>
-
       <varlistentry id="opt.redzone">
         <term>
           <mallctl>opt.redzone</mallctl>
diff --git a/include/jemalloc/internal/arena.h b/include/jemalloc/internal/arena.h
index b1de2b6..1c63620 100644
--- a/include/jemalloc/internal/arena.h
+++ b/include/jemalloc/internal/arena.h
@@ -551,7 +551,6 @@ extern arena_dalloc_junk_small_t *arena_dalloc_junk_small;
 #else
 void	arena_dalloc_junk_small(void *ptr, arena_bin_info_t *bin_info);
 #endif
-void	arena_quarantine_junk_small(void *ptr, size_t usize);
 void	*arena_malloc_large(tsdn_t *tsdn, arena_t *arena, szind_t ind,
     bool zero);
 void	*arena_malloc_hard(tsdn_t *tsdn, arena_t *arena, size_t size,
@@ -581,7 +580,7 @@ extern arena_ralloc_junk_large_t *arena_ralloc_junk_large;
 #endif
 bool	arena_ralloc_no_move(tsdn_t *tsdn, void *ptr, size_t oldsize,
     size_t size, size_t extra, bool zero);
-void	*arena_ralloc(tsd_t *tsd, arena_t *arena, void *ptr, size_t oldsize,
+void	*arena_ralloc(tsdn_t *tsdn, arena_t *arena, void *ptr, size_t oldsize,
     size_t size, size_t alignment, bool zero, tcache_t *tcache);
 dss_prec_t	arena_dss_prec_get(tsdn_t *tsdn, arena_t *arena);
 bool	arena_dss_prec_set(tsdn_t *tsdn, arena_t *arena, dss_prec_t dss_prec);
diff --git a/include/jemalloc/internal/huge.h b/include/jemalloc/internal/huge.h
index b5fa9e6..8b501e5 100644
--- a/include/jemalloc/internal/huge.h
+++ b/include/jemalloc/internal/huge.h
@@ -14,7 +14,7 @@ void	*huge_palloc(tsdn_t *tsdn, arena_t *arena, size_t usize,
     size_t alignment, bool zero);
 bool	huge_ralloc_no_move(tsdn_t *tsdn, void *ptr, size_t oldsize,
     size_t usize_min, size_t usize_max, bool zero);
-void	*huge_ralloc(tsd_t *tsd, arena_t *arena, void *ptr, size_t oldsize,
+void	*huge_ralloc(tsdn_t *tsdn, arena_t *arena, void *ptr, size_t oldsize,
     size_t usize, size_t alignment, bool zero, tcache_t *tcache);
 #ifdef JEMALLOC_JET
 typedef void (huge_dalloc_junk_t)(tsdn_t *, void *, size_t);
diff --git a/include/jemalloc/internal/jemalloc_internal.h.in b/include/jemalloc/internal/jemalloc_internal.h.in
index 4c845e3..c6aa574 100644
--- a/include/jemalloc/internal/jemalloc_internal.h.in
+++ b/include/jemalloc/internal/jemalloc_internal.h.in
@@ -377,7 +377,6 @@ typedef unsigned szind_t;
 #include "jemalloc/internal/huge.h"
 #include "jemalloc/internal/tcache.h"
 #include "jemalloc/internal/hash.h"
-#include "jemalloc/internal/quarantine.h"
 #include "jemalloc/internal/prof.h"
 
 #undef JEMALLOC_H_TYPES
@@ -412,7 +411,6 @@ typedef unsigned szind_t;
 #include "jemalloc/internal/huge.h"
 #include "jemalloc/internal/tcache.h"
 #include "jemalloc/internal/hash.h"
-#include "jemalloc/internal/quarantine.h"
 #include "jemalloc/internal/prof.h"
 
 #include "jemalloc/internal/tsd.h"
@@ -425,7 +423,6 @@ extern bool	opt_abort;
 extern const char	*opt_junk;
 extern bool	opt_junk_alloc;
 extern bool	opt_junk_free;
-extern size_t	opt_quarantine;
 extern bool	opt_redzone;
 extern bool	opt_utrace;
 extern bool	opt_xmalloc;
@@ -500,7 +497,6 @@ void	jemalloc_postfork_child(void);
 #include "jemalloc/internal/huge.h"
 #include "jemalloc/internal/tcache.h"
 #include "jemalloc/internal/hash.h"
-#include "jemalloc/internal/quarantine.h"
 #include "jemalloc/internal/prof.h"
 #include "jemalloc/internal/tsd.h"
 
@@ -878,7 +874,6 @@ decay_ticker_get(tsd_t *tsd, unsigned ind)
 #include "jemalloc/internal/arena.h"
 #undef JEMALLOC_ARENA_INLINE_B
 #include "jemalloc/internal/hash.h"
-#include "jemalloc/internal/quarantine.h"
 
 #ifndef JEMALLOC_ENABLE_INLINE
 arena_t	*iaalloc(const void *ptr);
@@ -898,15 +893,12 @@ size_t	p2rz(tsdn_t *tsdn, const void *ptr);
 void	idalloctm(tsdn_t *tsdn, void *ptr, tcache_t *tcache, bool is_metadata,
     bool slow_path);
 void	idalloc(tsd_t *tsd, void *ptr);
-void	iqalloc(tsd_t *tsd, void *ptr, tcache_t *tcache, bool slow_path);
 void	isdalloct(tsdn_t *tsdn, void *ptr, size_t size, tcache_t *tcache,
     bool slow_path);
-void	isqalloc(tsd_t *tsd, void *ptr, size_t size, tcache_t *tcache,
-    bool slow_path);
-void	*iralloct_realign(tsd_t *tsd, void *ptr, size_t oldsize, size_t size,
+void	*iralloct_realign(tsdn_t *tsdn, void *ptr, size_t oldsize, size_t size,
     size_t extra, size_t alignment, bool zero, tcache_t *tcache,
     arena_t *arena);
-void	*iralloct(tsd_t *tsd, void *ptr, size_t oldsize, size_t size,
+void	*iralloct(tsdn_t *tsdn, void *ptr, size_t oldsize, size_t size,
     size_t alignment, bool zero, tcache_t *tcache, arena_t *arena);
 void	*iralloc(tsd_t *tsd, void *ptr, size_t oldsize, size_t size,
     size_t alignment, bool zero);
@@ -1065,16 +1057,6 @@ idalloc(tsd_t *tsd, void *ptr)
 }
 
 JEMALLOC_ALWAYS_INLINE void
-iqalloc(tsd_t *tsd, void *ptr, tcache_t *tcache, bool slow_path)
-{
-
-	if (slow_path && config_fill && unlikely(opt_quarantine))
-		quarantine(tsd, ptr);
-	else
-		idalloctm(tsd_tsdn(tsd), ptr, tcache, false, slow_path);
-}
-
-JEMALLOC_ALWAYS_INLINE void
 isdalloct(tsdn_t *tsdn, void *ptr, size_t size, tcache_t *tcache,
     bool slow_path)
 {
@@ -1082,18 +1064,8 @@ isdalloct(tsdn_t *tsdn, void *ptr, size_t size, tcache_t *tcache,
 	arena_sdalloc(tsdn, ptr, size, tcache, slow_path);
 }
 
-JEMALLOC_ALWAYS_INLINE void
-isqalloc(tsd_t *tsd, void *ptr, size_t size, tcache_t *tcache, bool slow_path)
-{
-
-	if (slow_path && config_fill && unlikely(opt_quarantine))
-		quarantine(tsd, ptr);
-	else
-		isdalloct(tsd_tsdn(tsd), ptr, size, tcache, slow_path);
-}
-
 JEMALLOC_ALWAYS_INLINE void *
-iralloct_realign(tsd_t *tsd, void *ptr, size_t oldsize, size_t size,
+iralloct_realign(tsdn_t *tsdn, void *ptr, size_t oldsize, size_t size,
     size_t extra, size_t alignment, bool zero, tcache_t *tcache, arena_t *arena)
 {
 	void *p;
@@ -1102,7 +1074,7 @@ iralloct_realign(tsd_t *tsd, void *ptr, size_t oldsize, size_t size,
 	usize = sa2u(size + extra, alignment);
 	if (unlikely(usize == 0 || usize > HUGE_MAXCLASS))
 		return (NULL);
-	p = ipalloct(tsd_tsdn(tsd), usize, alignment, zero, tcache, arena);
+	p = ipalloct(tsdn, usize, alignment, zero, tcache, arena);
 	if (p == NULL) {
 		if (extra == 0)
 			return (NULL);
@@ -1110,8 +1082,7 @@ iralloct_realign(tsd_t *tsd, void *ptr, size_t oldsize, size_t size,
 		usize = sa2u(size, alignment);
 		if (unlikely(usize == 0 || usize > HUGE_MAXCLASS))
 			return (NULL);
-		p = ipalloct(tsd_tsdn(tsd), usize, alignment, zero, tcache,
-		    arena);
+		p = ipalloct(tsdn, usize, alignment, zero, tcache, arena);
 		if (p == NULL)
 			return (NULL);
 	}
@@ -1121,12 +1092,12 @@ iralloct_realign(tsd_t *tsd, void *ptr, size_t oldsize, size_t size,
 	 */
 	copysize = (size < oldsize) ? size : oldsize;
 	memcpy(p, ptr, copysize);
-	isqalloc(tsd, ptr, oldsize, tcache, true);
+	isdalloct(tsdn, ptr, oldsize, tcache, true);
 	return (p);
 }
 
 JEMALLOC_ALWAYS_INLINE void *
-iralloct(tsd_t *tsd, void *ptr, size_t oldsize, size_t size, size_t alignment,
+iralloct(tsdn_t *tsdn, void *ptr, size_t oldsize, size_t size, size_t alignment,
     bool zero, tcache_t *tcache, arena_t *arena)
 {
 
@@ -1139,11 +1110,11 @@ iralloct(tsd_t *tsd, void *ptr, size_t oldsize, size_t size, size_t alignment,
 		 * Existing object alignment is inadequate; allocate new space
 		 * and copy.
 		 */
-		return (iralloct_realign(tsd, ptr, oldsize, size, 0, alignment,
+		return (iralloct_realign(tsdn, ptr, oldsize, size, 0, alignment,
 		    zero, tcache, arena));
 	}
 
-	return (arena_ralloc(tsd, arena, ptr, oldsize, size, alignment, zero,
+	return (arena_ralloc(tsdn, arena, ptr, oldsize, size, alignment, zero,
 	    tcache));
 }
 
@@ -1152,7 +1123,7 @@ iralloc(tsd_t *tsd, void *ptr, size_t oldsize, size_t size, size_t alignment,
     bool zero)
 {
 
-	return (iralloct(tsd, ptr, oldsize, size, alignment, zero,
+	return (iralloct(tsd_tsdn(tsd), ptr, oldsize, size, alignment, zero,
 	    tcache_get(tsd, true), NULL));
 }
 
diff --git a/include/jemalloc/internal/jemalloc_internal_defs.h.in b/include/jemalloc/internal/jemalloc_internal_defs.h.in
index c9aa5fd..5e5b0a7 100644
--- a/include/jemalloc/internal/jemalloc_internal_defs.h.in
+++ b/include/jemalloc/internal/jemalloc_internal_defs.h.in
@@ -142,7 +142,7 @@
  */
 #undef JEMALLOC_DSS
 
-/* Support memory filling (junk/zero/quarantine/redzone). */
+/* Support memory filling (junk/zero/redzone). */
 #undef JEMALLOC_FILL
 
 /* Support utrace(2)-based tracing. */
diff --git a/include/jemalloc/internal/private_symbols.txt b/include/jemalloc/internal/private_symbols.txt
index 15b8cee..0237780 100644
--- a/include/jemalloc/internal/private_symbols.txt
+++ b/include/jemalloc/internal/private_symbols.txt
@@ -99,7 +99,6 @@ arena_prof_tctx_reset
 arena_prof_tctx_set
 arena_ptr_small_binind_get
 arena_purge
-arena_quarantine_junk_small
 arena_ralloc
 arena_ralloc_junk_large
 arena_ralloc_no_move
@@ -303,13 +302,11 @@ index2size_tab
 ipalloc
 ipalloct
 ipallocztm
-iqalloc
 iralloc
 iralloct
 iralloct_realign
 isalloc
 isdalloct
-isqalloc
 isthreaded
 ivsalloc
 ixalloc
@@ -385,7 +382,6 @@ opt_prof_leak
 opt_prof_prefix
 opt_prof_thread_active_init
 opt_purge
-opt_quarantine
 opt_redzone
 opt_stats_print
 opt_tcache
@@ -454,10 +450,6 @@ prof_thread_active_set
 prof_thread_name_get
 prof_thread_name_set
 purge_mode_names
-quarantine
-quarantine_alloc_hook
-quarantine_alloc_hook_work
-quarantine_cleanup
 register_zone
 rtree_child_read
 rtree_child_read_hard
@@ -561,9 +553,6 @@ tsd_nominal
 tsd_prof_tdata_get
 tsd_prof_tdata_set
 tsd_prof_tdatap_get
-tsd_quarantine_get
-tsd_quarantine_set
-tsd_quarantinep_get
 tsd_set
 tsd_tcache_enabled_get
 tsd_tcache_enabled_set
diff --git a/include/jemalloc/internal/quarantine.h b/include/jemalloc/internal/quarantine.h
deleted file mode 100644
index 1ab4345..0000000
--- a/include/jemalloc/internal/quarantine.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/******************************************************************************/
-#ifdef JEMALLOC_H_TYPES
-
-typedef struct quarantine_obj_s quarantine_obj_t;
-typedef struct quarantine_s quarantine_t;
-
-#endif /* JEMALLOC_H_TYPES */
-/******************************************************************************/
-#ifdef JEMALLOC_H_STRUCTS
-
-struct quarantine_obj_s {
-	void	*ptr;
-	size_t	usize;
-};
-
-struct quarantine_s {
-	size_t			curbytes;
-	size_t			curobjs;
-	size_t			first;
-#define	LG_MAXOBJS_INIT 10
-	size_t			lg_maxobjs;
-	quarantine_obj_t	objs[1]; /* Dynamically sized ring buffer. */
-};
-
-#endif /* JEMALLOC_H_STRUCTS */
-/******************************************************************************/
-#ifdef JEMALLOC_H_EXTERNS
-
-void	quarantine_alloc_hook_work(tsd_t *tsd);
-void	quarantine(tsd_t *tsd, void *ptr);
-void	quarantine_cleanup(tsd_t *tsd);
-
-#endif /* JEMALLOC_H_EXTERNS */
-/******************************************************************************/
-#ifdef JEMALLOC_H_INLINES
-
-#ifndef JEMALLOC_ENABLE_INLINE
-void	quarantine_alloc_hook(void);
-#endif
-
-#if (defined(JEMALLOC_ENABLE_INLINE) || defined(JEMALLOC_QUARANTINE_C_))
-JEMALLOC_ALWAYS_INLINE void
-quarantine_alloc_hook(void)
-{
-	tsd_t *tsd;
-
-	assert(config_fill && opt_quarantine);
-
-	tsd = tsd_fetch();
-	if (tsd_quarantine_get(tsd) == NULL)
-		quarantine_alloc_hook_work(tsd);
-}
-#endif
-
-#endif /* JEMALLOC_H_INLINES */
-/******************************************************************************/
-
diff --git a/include/jemalloc/internal/tsd.h b/include/jemalloc/internal/tsd.h
index bf11341..f4ff8d7 100644
--- a/include/jemalloc/internal/tsd.h
+++ b/include/jemalloc/internal/tsd.h
@@ -572,7 +572,6 @@ struct tsd_init_head_s {
     O(narenas_tdata,		unsigned)				\
     O(arenas_tdata_bypass,	bool)					\
     O(tcache_enabled,		tcache_enabled_t)			\
-    O(quarantine,		quarantine_t *)				\
     O(witnesses,		witness_list_t)				\
     O(witness_fork,		bool)					\
 
@@ -588,7 +587,6 @@ struct tsd_init_head_s {
     0,									\
     false,								\
     tcache_enabled_default,						\
-    NULL,								\
     ql_head_initializer(witnesses),					\
     false								\
 }
diff --git a/msvc/projects/vc2015/jemalloc/jemalloc.vcxproj b/msvc/projects/vc2015/jemalloc/jemalloc.vcxproj
index 432d1f2..537cb6a 100644
--- a/msvc/projects/vc2015/jemalloc/jemalloc.vcxproj
+++ b/msvc/projects/vc2015/jemalloc/jemalloc.vcxproj
@@ -65,7 +65,6 @@
     <ClInclude Include="..\..\..\..\include\jemalloc\internal\public_unnamespace.h" />
     <ClInclude Include="..\..\..\..\include\jemalloc\internal\ql.h" />
     <ClInclude Include="..\..\..\..\include\jemalloc\internal\qr.h" />
-    <ClInclude Include="..\..\..\..\include\jemalloc\internal\quarantine.h" />
     <ClInclude Include="..\..\..\..\include\jemalloc\internal\rb.h" />
     <ClInclude Include="..\..\..\..\include\jemalloc\internal\rtree.h" />
     <ClInclude Include="..\..\..\..\include\jemalloc\internal\size_classes.h" />
@@ -107,7 +106,6 @@
     <ClCompile Include="..\..\..\..\src\pages.c" />
     <ClCompile Include="..\..\..\..\src\prng.c" />
     <ClCompile Include="..\..\..\..\src\prof.c" />
-    <ClCompile Include="..\..\..\..\src\quarantine.c" />
     <ClCompile Include="..\..\..\..\src\rtree.c" />
     <ClCompile Include="..\..\..\..\src\stats.c" />
     <ClCompile Include="..\..\..\..\src\tcache.c" />
diff --git a/msvc/projects/vc2015/jemalloc/jemalloc.vcxproj.filters b/msvc/projects/vc2015/jemalloc/jemalloc.vcxproj.filters
index c0e568e..d2b5595 100644
--- a/msvc/projects/vc2015/jemalloc/jemalloc.vcxproj.filters
+++ b/msvc/projects/vc2015/jemalloc/jemalloc.vcxproj.filters
@@ -134,9 +134,6 @@
     <ClInclude Include="..\..\..\..\include\jemalloc\internal\qr.h">
       <Filter>Header Files\internal</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\..\..\include\jemalloc\internal\quarantine.h">
-      <Filter>Header Files\internal</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\..\..\include\jemalloc\internal\rb.h">
       <Filter>Header Files\internal</Filter>
     </ClInclude>
@@ -232,9 +229,6 @@
     <ClCompile Include="..\..\..\..\src\prof.c">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\..\..\src\quarantine.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="..\..\..\..\src\rtree.c">
       <Filter>Source Files</Filter>
     </ClCompile>
diff --git a/src/arena.c b/src/arena.c
index 4e6d3d6..607679d 100644
--- a/src/arena.c
+++ b/src/arena.c
@@ -2484,21 +2484,6 @@ arena_dalloc_junk_small_t *arena_dalloc_junk_small =
     JEMALLOC_N(n_arena_dalloc_junk_small);
 #endif
 
-void
-arena_quarantine_junk_small(void *ptr, size_t usize)
-{
-	szind_t binind;
-	arena_bin_info_t *bin_info;
-	cassert(config_fill);
-	assert(opt_junk_free);
-	assert(opt_quarantine);
-	assert(usize <= SMALL_MAXCLASS);
-
-	binind = size2index(usize);
-	bin_info = &arena_bin_info[binind];
-	arena_redzones_validate(ptr, bin_info, true);
-}
-
 static void *
 arena_malloc_small(tsdn_t *tsdn, arena_t *arena, szind_t binind, bool zero)
 {
@@ -3243,8 +3228,8 @@ arena_ralloc_move_helper(tsdn_t *tsdn, arena_t *arena, size_t usize,
 }
 
 void *
-arena_ralloc(tsd_t *tsd, arena_t *arena, void *ptr, size_t oldsize, size_t size,
-    size_t alignment, bool zero, tcache_t *tcache)
+arena_ralloc(tsdn_t *tsdn, arena_t *arena, void *ptr, size_t oldsize,
+    size_t size, size_t alignment, bool zero, tcache_t *tcache)
 {
 	void *ret;
 	size_t usize;
@@ -3257,8 +3242,7 @@ arena_ralloc(tsd_t *tsd, arena_t *arena, void *ptr, size_t oldsize, size_t size,
 		size_t copysize;
 
 		/* Try to avoid moving the allocation. */
-		if (!arena_ralloc_no_move(tsd_tsdn(tsd), ptr, oldsize, usize, 0,
-		    zero))
+		if (!arena_ralloc_no_move(tsdn, ptr, oldsize, usize, 0, zero))
 			return (ptr);
 
 		/*
@@ -3266,8 +3250,8 @@ arena_ralloc(tsd_t *tsd, arena_t *arena, void *ptr, size_t oldsize, size_t size,
 		 * the object.  In that case, fall back to allocating new space
 		 * and copying.
 		 */
-		ret = arena_ralloc_move_helper(tsd_tsdn(tsd), arena, usize,
-		    alignment, zero, tcache);
+		ret = arena_ralloc_move_helper(tsdn, arena, usize, alignment,
+		    zero, tcache);
 		if (ret == NULL)
 			return (NULL);
 
@@ -3278,9 +3262,9 @@ arena_ralloc(tsd_t *tsd, arena_t *arena, void *ptr, size_t oldsize, size_t size,
 
 		copysize = (usize < oldsize) ? usize : oldsize;
 		memcpy(ret, ptr, copysize);
-		isqalloc(tsd, ptr, oldsize, tcache, true);
+		isdalloct(tsdn, ptr, oldsize, tcache, true);
 	} else {
-		ret = huge_ralloc(tsd, arena, ptr, oldsize, usize, alignment,
+		ret = huge_ralloc(tsdn, arena, ptr, oldsize, usize, alignment,
 		    zero, tcache);
 	}
 	return (ret);
diff --git a/src/ctl.c b/src/ctl.c
index d2e9426..f4c775d 100644
--- a/src/ctl.c
+++ b/src/ctl.c
@@ -97,7 +97,6 @@ CTL_PROTO(opt_decay_time)
 CTL_PROTO(opt_stats_print)
 CTL_PROTO(opt_junk)
 CTL_PROTO(opt_zero)
-CTL_PROTO(opt_quarantine)
 CTL_PROTO(opt_redzone)
 CTL_PROTO(opt_utrace)
 CTL_PROTO(opt_xmalloc)
@@ -273,7 +272,6 @@ static const ctl_named_node_t opt_node[] = {
 	{NAME("stats_print"),	CTL(opt_stats_print)},
 	{NAME("junk"),		CTL(opt_junk)},
 	{NAME("zero"),		CTL(opt_zero)},
-	{NAME("quarantine"),	CTL(opt_quarantine)},
 	{NAME("redzone"),	CTL(opt_redzone)},
 	{NAME("utrace"),	CTL(opt_utrace)},
 	{NAME("xmalloc"),	CTL(opt_xmalloc)},
@@ -1281,7 +1279,6 @@ CTL_RO_NL_GEN(opt_lg_dirty_mult, opt_lg_dirty_mult, ssize_t)
 CTL_RO_NL_GEN(opt_decay_time, opt_decay_time, ssize_t)
 CTL_RO_NL_GEN(opt_stats_print, opt_stats_print, bool)
 CTL_RO_NL_CGEN(config_fill, opt_junk, opt_junk, const char *)
-CTL_RO_NL_CGEN(config_fill, opt_quarantine, opt_quarantine, size_t)
 CTL_RO_NL_CGEN(config_fill, opt_redzone, opt_redzone, bool)
 CTL_RO_NL_CGEN(config_fill, opt_zero, opt_zero, bool)
 CTL_RO_NL_CGEN(config_utrace, opt_utrace, opt_utrace, bool)
@@ -1619,11 +1616,6 @@ arena_i_reset_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,
 	READONLY();
 	WRITEONLY();
 
-	if (config_fill && unlikely(opt_quarantine)) {
-		ret = EFAULT;
-		goto label_return;
-	}
-
 	arena_ind = (unsigned)mib[1];
 	if (config_debug) {
 		malloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);
diff --git a/src/huge.c b/src/huge.c
index 1aa02a0..b1ff918 100644
--- a/src/huge.c
+++ b/src/huge.c
@@ -359,7 +359,7 @@ huge_ralloc_move_helper(tsdn_t *tsdn, arena_t *arena, size_t usize,
 }
 
 void *
-huge_ralloc(tsd_t *tsd, arena_t *arena, void *ptr, size_t oldsize,
+huge_ralloc(tsdn_t *tsdn, arena_t *arena, void *ptr, size_t oldsize,
     size_t usize, size_t alignment, bool zero, tcache_t *tcache)
 {
 	void *ret;
@@ -369,8 +369,7 @@ huge_ralloc(tsd_t *tsd, arena_t *arena, void *ptr, size_t oldsize,
 	assert(usize > 0 && usize <= HUGE_MAXCLASS);
 
 	/* Try to avoid moving the allocation. */
-	if (!huge_ralloc_no_move(tsd_tsdn(tsd), ptr, oldsize, usize, usize,
-	    zero))
+	if (!huge_ralloc_no_move(tsdn, ptr, oldsize, usize, usize, zero))
 		return (ptr);
 
 	/*
@@ -378,14 +377,13 @@ huge_ralloc(tsd_t *tsd, arena_t *arena, void *ptr, size_t oldsize,
 	 * different size class.  In that case, fall back to allocating new
 	 * space and copying.
 	 */
-	ret = huge_ralloc_move_helper(tsd_tsdn(tsd), arena, usize, alignment,
-	    zero);
+	ret = huge_ralloc_move_helper(tsdn, arena, usize, alignment, zero);
 	if (ret == NULL)
 		return (NULL);
 
 	copysize = (usize < oldsize) ? usize : oldsize;
 	memcpy(ret, ptr, copysize);
-	isqalloc(tsd, ptr, oldsize, tcache, true);
+	isdalloct(tsdn, ptr, oldsize, tcache, true);
 	return (ret);
 }
 
diff --git a/src/jemalloc.c b/src/jemalloc.c
index cfe6ed3..4dd77e6 100644
--- a/src/jemalloc.c
+++ b/src/jemalloc.c
@@ -35,7 +35,6 @@ bool	opt_junk_free =
 #endif
     ;
 
-size_t	opt_quarantine = ZU(0);
 bool	opt_redzone = false;
 bool	opt_utrace = false;
 bool	opt_xmalloc = false;
@@ -74,10 +73,9 @@ static bool	malloc_slow = true;
 enum {
 	flag_opt_junk_alloc	= (1U),
 	flag_opt_junk_free	= (1U << 1),
-	flag_opt_quarantine	= (1U << 2),
-	flag_opt_zero		= (1U << 3),
-	flag_opt_utrace		= (1U << 4),
-	flag_opt_xmalloc	= (1U << 5)
+	flag_opt_zero		= (1U << 2),
+	flag_opt_utrace		= (1U << 3),
+	flag_opt_xmalloc	= (1U << 4)
 };
 static uint8_t	malloc_slow_flags;
 
@@ -265,23 +263,6 @@ malloc_initialized(void)
 	return (malloc_init_state == malloc_init_initialized);
 }
 
-JEMALLOC_ALWAYS_INLINE_C void
-malloc_thread_init(void)
-{
-
-	/*
-	 * TSD initialization can't be safely done as a side effect of
-	 * deallocation, because it is possible for a thread to do nothing but
-	 * deallocate its TLS data via free(), in which case writing to TLS
-	 * would cause write-after-free memory corruption.  The quarantine
-	 * facility *only* gets used as a side effect of deallocation, so make
-	 * a best effort attempt at initializing its TSD by hooking all
-	 * allocation events.
-	 */
-	if (config_fill && unlikely(opt_quarantine))
-		quarantine_alloc_hook();
-}
-
 JEMALLOC_ALWAYS_INLINE_C bool
 malloc_init_a0(void)
 {
@@ -297,8 +278,6 @@ malloc_init(void)
 
 	if (unlikely(!malloc_initialized()) && malloc_init_hard())
 		return (true);
-	malloc_thread_init();
-
 	return (false);
 }
 
@@ -885,7 +864,6 @@ malloc_slow_flag_init(void)
 	 */
 	malloc_slow_flags |= (opt_junk_alloc ? flag_opt_junk_alloc : 0)
 	    | (opt_junk_free ? flag_opt_junk_free : 0)
-	    | (opt_quarantine ? flag_opt_quarantine : 0)
 	    | (opt_zero ? flag_opt_zero : 0)
 	    | (opt_utrace ? flag_opt_utrace : 0)
 	    | (opt_xmalloc ? flag_opt_xmalloc : 0);
@@ -1146,8 +1124,6 @@ malloc_conf_init(void)
 					}
 					continue;
 				}
-				CONF_HANDLE_SIZE_T(opt_quarantine, "quarantine",
-				    0, SIZE_T_MAX, false)
 				CONF_HANDLE_BOOL(opt_redzone, "redzone", true)
 				CONF_HANDLE_BOOL(opt_zero, "zero", true)
 			}
@@ -1761,9 +1737,9 @@ ifree(tsd_t *tsd, void *ptr, tcache_t *tcache, bool slow_path)
 		*tsd_thread_deallocatedp_get(tsd) += usize;
 
 	if (likely(!slow_path))
-		iqalloc(tsd, ptr, tcache, false);
+		idalloctm(tsd_tsdn(tsd), ptr, tcache, false, false);
 	else
-		iqalloc(tsd, ptr, tcache, true);
+		idalloctm(tsd_tsdn(tsd), ptr, tcache, false, true);
 }
 
 JEMALLOC_INLINE_C void
@@ -1779,7 +1755,11 @@ isfree(tsd_t *tsd, void *ptr, size_t usize, tcache_t *tcache, bool slow_path)
 		prof_free(tsd, ptr, usize);
 	if (config_stats)
 		*tsd_thread_deallocatedp_get(tsd) += usize;
-	isqalloc(tsd, ptr, usize, tcache, slow_path);
+
+	if (likely(!slow_path))
+		isdalloct(tsd_tsdn(tsd), ptr, usize, tcache, false);
+	else
+		isdalloct(tsd_tsdn(tsd), ptr, usize, tcache, true);
 }
 
 JEMALLOC_EXPORT JEMALLOC_ALLOCATOR JEMALLOC_RESTRICT_RETURN
@@ -1809,7 +1789,6 @@ je_realloc(void *ptr, size_t size)
 		tsd_t *tsd;
 
 		assert(malloc_initialized() || IS_INITIALIZER);
-		malloc_thread_init();
 		tsd = tsd_fetch();
 
 		witness_assert_lockless(tsd_tsdn(tsd));
@@ -2123,7 +2102,7 @@ je_mallocx(size_t size, int flags)
 }
 
 static void *
-irallocx_prof_sample(tsd_t *tsd, void *old_ptr, size_t old_usize,
+irallocx_prof_sample(tsdn_t *tsdn, void *old_ptr, size_t old_usize,
     size_t usize, size_t alignment, bool zero, tcache_t *tcache, arena_t *arena,
     prof_tctx_t *tctx)
 {
@@ -2132,13 +2111,13 @@ irallocx_prof_sample(tsd_t *tsd, void *old_ptr, size_t old_usize,
 	if (tctx == NULL)
 		return (NULL);
 	if (usize <= SMALL_MAXCLASS) {
-		p = iralloct(tsd, old_ptr, old_usize, LARGE_MINCLASS, alignment,
-		    zero, tcache, arena);
+		p = iralloct(tsdn, old_ptr, old_usize, LARGE_MINCLASS,
+		    alignment, zero, tcache, arena);
 		if (p == NULL)
 			return (NULL);
-		arena_prof_promoted(tsd_tsdn(tsd), p, usize);
+		arena_prof_promoted(tsdn, p, usize);
 	} else {
-		p = iralloct(tsd, old_ptr, old_usize, usize, alignment, zero,
+		p = iralloct(tsdn, old_ptr, old_usize, usize, alignment, zero,
 		    tcache, arena);
 	}
 
@@ -2158,11 +2137,11 @@ irallocx_prof(tsd_t *tsd, void *old_ptr, size_t old_usize, size_t size,
 	old_tctx = prof_tctx_get(tsd_tsdn(tsd), old_ptr);
 	tctx = prof_alloc_prep(tsd, *usize, prof_active, true);
 	if (unlikely((uintptr_t)tctx != (uintptr_t)1U)) {
-		p = irallocx_prof_sample(tsd, old_ptr, old_usize, *usize,
-		    alignment, zero, tcache, arena, tctx);
+		p = irallocx_prof_sample(tsd_tsdn(tsd), old_ptr, old_usize,
+		    *usize, alignment, zero, tcache, arena, tctx);
 	} else {
-		p = iralloct(tsd, old_ptr, old_usize, size, alignment, zero,
-		    tcache, arena);
+		p = iralloct(tsd_tsdn(tsd), old_ptr, old_usize, size, alignment,
+		    zero, tcache, arena);
 	}
 	if (unlikely(p == NULL)) {
 		prof_alloc_rollback(tsd, tctx, true);
@@ -2203,7 +2182,6 @@ je_rallocx(void *ptr, size_t size, int flags)
 	assert(ptr != NULL);
 	assert(size != 0);
 	assert(malloc_initialized() || IS_INITIALIZER);
-	malloc_thread_init();
 	tsd = tsd_fetch();
 	witness_assert_lockless(tsd_tsdn(tsd));
 
@@ -2234,8 +2212,8 @@ je_rallocx(void *ptr, size_t size, int flags)
 		if (unlikely(p == NULL))
 			goto label_oom;
 	} else {
-		p = iralloct(tsd, ptr, old_usize, size, alignment, zero,
-		     tcache, arena);
+		p = iralloct(tsd_tsdn(tsd), ptr, old_usize, size, alignment,
+		    zero, tcache, arena);
 		if (unlikely(p == NULL))
 			goto label_oom;
 		if (config_stats)
@@ -2349,7 +2327,6 @@ je_xallocx(void *ptr, size_t size, size_t extra, int flags)
 	assert(size != 0);
 	assert(SIZE_T_MAX - size >= extra);
 	assert(malloc_initialized() || IS_INITIALIZER);
-	malloc_thread_init();
 	tsd = tsd_fetch();
 	witness_assert_lockless(tsd_tsdn(tsd));
 
@@ -2399,7 +2376,6 @@ je_sallocx(const void *ptr, int flags)
 	tsdn_t *tsdn;
 
 	assert(malloc_initialized() || IS_INITIALIZER);
-	malloc_thread_init();
 
 	tsdn = tsdn_fetch();
 	witness_assert_lockless(tsdn);
@@ -2577,7 +2553,6 @@ je_malloc_usable_size(JEMALLOC_USABLE_SIZE_CONST void *ptr)
 	tsdn_t *tsdn;
 
 	assert(malloc_initialized() || IS_INITIALIZER);
-	malloc_thread_init();
 
 	tsdn = tsdn_fetch();
 	witness_assert_lockless(tsdn);
diff --git a/src/quarantine.c b/src/quarantine.c
deleted file mode 100644
index 9658ffa..0000000
--- a/src/quarantine.c
+++ /dev/null
@@ -1,178 +0,0 @@
-#define	JEMALLOC_QUARANTINE_C_
-#include "jemalloc/internal/jemalloc_internal.h"
-
-/*
- * Quarantine pointers close to NULL are used to encode state information that
- * is used for cleaning up during thread shutdown.
- */
-#define	QUARANTINE_STATE_REINCARNATED	((quarantine_t *)(uintptr_t)1)
-#define	QUARANTINE_STATE_PURGATORY	((quarantine_t *)(uintptr_t)2)
-#define	QUARANTINE_STATE_MAX		QUARANTINE_STATE_PURGATORY
-
-/******************************************************************************/
-/* Function prototypes for non-inline static functions. */
-
-static quarantine_t	*quarantine_grow(tsd_t *tsd, quarantine_t *quarantine);
-static void	quarantine_drain_one(tsdn_t *tsdn, quarantine_t *quarantine);
-static void	quarantine_drain(tsdn_t *tsdn, quarantine_t *quarantine,
-    size_t upper_bound);
-
-/******************************************************************************/
-
-static quarantine_t *
-quarantine_init(tsdn_t *tsdn, size_t lg_maxobjs)
-{
-	quarantine_t *quarantine;
-	size_t size;
-
-	size = offsetof(quarantine_t, objs) + ((ZU(1) << lg_maxobjs) *
-	    sizeof(quarantine_obj_t));
-	quarantine = (quarantine_t *)iallocztm(tsdn, size, size2index(size),
-	    false, NULL, true, arena_get(TSDN_NULL, 0, true), true);
-	if (quarantine == NULL)
-		return (NULL);
-	quarantine->curbytes = 0;
-	quarantine->curobjs = 0;
-	quarantine->first = 0;
-	quarantine->lg_maxobjs = lg_maxobjs;
-
-	return (quarantine);
-}
-
-void
-quarantine_alloc_hook_work(tsd_t *tsd)
-{
-	quarantine_t *quarantine;
-
-	if (!tsd_nominal(tsd))
-		return;
-
-	quarantine = quarantine_init(tsd_tsdn(tsd), LG_MAXOBJS_INIT);
-	/*
-	 * Check again whether quarantine has been initialized, because
-	 * quarantine_init() may have triggered recursive initialization.
-	 */
-	if (tsd_quarantine_get(tsd) == NULL)
-		tsd_quarantine_set(tsd, quarantine);
-	else
-		idalloctm(tsd_tsdn(tsd), quarantine, NULL, true, true);
-}
-
-static quarantine_t *
-quarantine_grow(tsd_t *tsd, quarantine_t *quarantine)
-{
-	quarantine_t *ret;
-
-	ret = quarantine_init(tsd_tsdn(tsd), quarantine->lg_maxobjs + 1);
-	if (ret == NULL) {
-		quarantine_drain_one(tsd_tsdn(tsd), quarantine);
-		return (quarantine);
-	}
-
-	ret->curbytes = quarantine->curbytes;
-	ret->curobjs = quarantine->curobjs;
-	if (quarantine->first + quarantine->curobjs <= (ZU(1) <<
-	    quarantine->lg_maxobjs)) {
-		/* objs ring buffer data are contiguous. */
-		memcpy(ret->objs, &quarantine->objs[quarantine->first],
-		    quarantine->curobjs * sizeof(quarantine_obj_t));
-	} else {
-		/* objs ring buffer data wrap around. */
-		size_t ncopy_a = (ZU(1) << quarantine->lg_maxobjs) -
-		    quarantine->first;
-		size_t ncopy_b = quarantine->curobjs - ncopy_a;
-
-		memcpy(ret->objs, &quarantine->objs[quarantine->first], ncopy_a
-		    * sizeof(quarantine_obj_t));
-		memcpy(&ret->objs[ncopy_a], quarantine->objs, ncopy_b *
-		    sizeof(quarantine_obj_t));
-	}
-	idalloctm(tsd_tsdn(tsd), quarantine, NULL, true, true);
-
-	tsd_quarantine_set(tsd, ret);
-	return (ret);
-}
-
-static void
-quarantine_drain_one(tsdn_t *tsdn, quarantine_t *quarantine)
-{
-	quarantine_obj_t *obj = &quarantine->objs[quarantine->first];
-	assert(obj->usize == isalloc(tsdn, obj->ptr, config_prof));
-	idalloctm(tsdn, obj->ptr, NULL, false, true);
-	quarantine->curbytes -= obj->usize;
-	quarantine->curobjs--;
-	quarantine->first = (quarantine->first + 1) & ((ZU(1) <<
-	    quarantine->lg_maxobjs) - 1);
-}
-
-static void
-quarantine_drain(tsdn_t *tsdn, quarantine_t *quarantine, size_t upper_bound)
-{
-
-	while (quarantine->curbytes > upper_bound && quarantine->curobjs > 0)
-		quarantine_drain_one(tsdn, quarantine);
-}
-
-void
-quarantine(tsd_t *tsd, void *ptr)
-{
-	quarantine_t *quarantine;
-	size_t usize = isalloc(tsd_tsdn(tsd), ptr, config_prof);
-
-	cassert(config_fill);
-	assert(opt_quarantine);
-
-	if ((quarantine = tsd_quarantine_get(tsd)) == NULL) {
-		idalloctm(tsd_tsdn(tsd), ptr, NULL, false, true);
-		return;
-	}
-	/*
-	 * Drain one or more objects if the quarantine size limit would be
-	 * exceeded by appending ptr.
-	 */
-	if (quarantine->curbytes + usize > opt_quarantine) {
-		size_t upper_bound = (opt_quarantine >= usize) ? opt_quarantine
-		    - usize : 0;
-		quarantine_drain(tsd_tsdn(tsd), quarantine, upper_bound);
-	}
-	/* Grow the quarantine ring buffer if it's full. */
-	if (quarantine->curobjs == (ZU(1) << quarantine->lg_maxobjs))
-		quarantine = quarantine_grow(tsd, quarantine);
-	/* quarantine_grow() must free a slot if it fails to grow. */
-	assert(quarantine->curobjs < (ZU(1) << quarantine->lg_maxobjs));
-	/* Append ptr if its size doesn't exceed the quarantine size. */
-	if (quarantine->curbytes + usize <= opt_quarantine) {
-		size_t offset = (quarantine->first + quarantine->curobjs) &
-		    ((ZU(1) << quarantine->lg_maxobjs) - 1);
-		quarantine_obj_t *obj = &quarantine->objs[offset];
-		obj->ptr = ptr;
-		obj->usize = usize;
-		quarantine->curbytes += usize;
-		quarantine->curobjs++;
-		if (config_fill && unlikely(opt_junk_free)) {
-			if (usize <= SMALL_MAXCLASS)
-				arena_quarantine_junk_small(ptr, usize);
-			else
-				memset(ptr, JEMALLOC_FREE_JUNK, usize);
-		}
-	} else {
-		assert(quarantine->curbytes == 0);
-		idalloctm(tsd_tsdn(tsd), ptr, NULL, false, true);
-	}
-}
-
-void
-quarantine_cleanup(tsd_t *tsd)
-{
-	quarantine_t *quarantine;
-
-	if (!config_fill)
-		return;
-
-	quarantine = tsd_quarantine_get(tsd);
-	if (quarantine != NULL) {
-		quarantine_drain(tsd_tsdn(tsd), quarantine, 0);
-		idalloctm(tsd_tsdn(tsd), quarantine, NULL, true, true);
-		tsd_quarantine_set(tsd, NULL);
-	}
-}
diff --git a/src/stats.c b/src/stats.c
index 97f901f..16e5b1a 100644
--- a/src/stats.c
+++ b/src/stats.c
@@ -513,7 +513,6 @@ stats_print(void (*write_cb)(void *, const char *), void *cbopaque,
 			OPT_WRITE_SSIZE_T_MUTABLE(decay_time, arenas.decay_time)
 		OPT_WRITE_BOOL(stats_print)
 		OPT_WRITE_CHAR_P(junk)
-		OPT_WRITE_SIZE_T(quarantine)
 		OPT_WRITE_BOOL(redzone)
 		OPT_WRITE_BOOL(zero)
 		OPT_WRITE_BOOL(utrace)
diff --git a/test/unit/arena_reset.c b/test/unit/arena_reset.c
index c602f0f..d7a02e0 100644
--- a/test/unit/arena_reset.c
+++ b/test/unit/arena_reset.c
@@ -88,8 +88,6 @@ TEST_BEGIN(test_arena_reset)
 	size_t mib[3];
 	tsdn_t *tsdn;
 
-	test_skip_if(config_fill && unlikely(opt_quarantine));
-
 	sz = sizeof(unsigned);
 	assert_d_eq(mallctl("arenas.extend", &arena_ind, &sz, NULL, 0), 0,
 	    "Unexpected mallctl() failure");
diff --git a/test/unit/junk.c b/test/unit/junk.c
index acddc60..cb262ec 100644
--- a/test/unit/junk.c
+++ b/test/unit/junk.c
@@ -5,7 +5,7 @@
 #    define JEMALLOC_TEST_JUNK_OPT "junk:true"
 #  endif
 const char *malloc_conf =
-    "abort:false,zero:false,redzone:true,quarantine:0," JEMALLOC_TEST_JUNK_OPT;
+    "abort:false,zero:false,redzone:true," JEMALLOC_TEST_JUNK_OPT;
 #endif
 
 static arena_dalloc_junk_small_t *arena_dalloc_junk_small_orig;
diff --git a/test/unit/mallctl.c b/test/unit/mallctl.c
index 641138a..151e7ad 100644
--- a/test/unit/mallctl.c
+++ b/test/unit/mallctl.c
@@ -168,7 +168,6 @@ TEST_BEGIN(test_mallctl_opt)
 	TEST_MALLCTL_OPT(ssize_t, decay_time, always);
 	TEST_MALLCTL_OPT(bool, stats_print, always);
 	TEST_MALLCTL_OPT(const char *, junk, fill);
-	TEST_MALLCTL_OPT(size_t, quarantine, fill);
 	TEST_MALLCTL_OPT(bool, redzone, fill);
 	TEST_MALLCTL_OPT(bool, zero, fill);
 	TEST_MALLCTL_OPT(bool, utrace, utrace);
diff --git a/test/unit/quarantine.c b/test/unit/quarantine.c
deleted file mode 100644
index bbd48a5..0000000
--- a/test/unit/quarantine.c
+++ /dev/null
@@ -1,108 +0,0 @@
-#include "test/jemalloc_test.h"
-
-#define	QUARANTINE_SIZE		8192
-#define	STRINGIFY_HELPER(x)	#x
-#define	STRINGIFY(x)		STRINGIFY_HELPER(x)
-
-#ifdef JEMALLOC_FILL
-const char *malloc_conf = "abort:false,junk:true,redzone:true,quarantine:"
-    STRINGIFY(QUARANTINE_SIZE);
-#endif
-
-void
-quarantine_clear(void)
-{
-	void *p;
-
-	p = mallocx(QUARANTINE_SIZE*2, 0);
-	assert_ptr_not_null(p, "Unexpected mallocx() failure");
-	dallocx(p, 0);
-}
-
-TEST_BEGIN(test_quarantine)
-{
-#define	SZ		ZU(256)
-#define	NQUARANTINED	(QUARANTINE_SIZE/SZ)
-	void *quarantined[NQUARANTINED+1];
-	size_t i, j;
-
-	test_skip_if(!config_fill);
-
-	assert_zu_eq(nallocx(SZ, 0), SZ,
-	    "SZ=%zu does not precisely equal a size class", SZ);
-
-	quarantine_clear();
-
-	/*
-	 * Allocate enough regions to completely fill the quarantine, plus one
-	 * more.  The last iteration occurs with a completely full quarantine,
-	 * but no regions should be drained from the quarantine until the last
-	 * deallocation occurs.  Therefore no region recycling should occur
-	 * until after this loop completes.
-	 */
-	for (i = 0; i < NQUARANTINED+1; i++) {
-		void *p = mallocx(SZ, 0);
-		assert_ptr_not_null(p, "Unexpected mallocx() failure");
-		quarantined[i] = p;
-		dallocx(p, 0);
-		for (j = 0; j < i; j++) {
-			assert_ptr_ne(p, quarantined[j],
-			    "Quarantined region recycled too early; "
-			    "i=%zu, j=%zu", i, j);
-		}
-	}
-#undef NQUARANTINED
-#undef SZ
-}
-TEST_END
-
-static bool detected_redzone_corruption;
-
-static void
-arena_redzone_corruption_replacement(void *ptr, size_t usize, bool after,
-    size_t offset, uint8_t byte)
-{
-
-	detected_redzone_corruption = true;
-}
-
-TEST_BEGIN(test_quarantine_redzone)
-{
-	char *s;
-	arena_redzone_corruption_t *arena_redzone_corruption_orig;
-
-	test_skip_if(!config_fill);
-
-	arena_redzone_corruption_orig = arena_redzone_corruption;
-	arena_redzone_corruption = arena_redzone_corruption_replacement;
-
-	/* Test underflow. */
-	detected_redzone_corruption = false;
-	s = (char *)mallocx(1, 0);
-	assert_ptr_not_null((void *)s, "Unexpected mallocx() failure");
-	s[-1] = 0xbb;
-	dallocx(s, 0);
-	assert_true(detected_redzone_corruption,
-	    "Did not detect redzone corruption");
-
-	/* Test overflow. */
-	detected_redzone_corruption = false;
-	s = (char *)mallocx(1, 0);
-	assert_ptr_not_null((void *)s, "Unexpected mallocx() failure");
-	s[sallocx(s, 0)] = 0xbb;
-	dallocx(s, 0);
-	assert_true(detected_redzone_corruption,
-	    "Did not detect redzone corruption");
-
-	arena_redzone_corruption = arena_redzone_corruption_orig;
-}
-TEST_END
-
-int
-main(void)
-{
-
-	return (test(
-	    test_quarantine,
-	    test_quarantine_redzone));
-}
diff --git a/test/unit/zero.c b/test/unit/zero.c
index 30ebe37..80b8fe1 100644
--- a/test/unit/zero.c
+++ b/test/unit/zero.c
@@ -2,7 +2,7 @@
 
 #ifdef JEMALLOC_FILL
 const char *malloc_conf =
-    "abort:false,junk:false,zero:true,redzone:false,quarantine:0";
+    "abort:false,junk:false,zero:true,redzone:false";
 #endif
 
 static void