Merge ~racb/ubuntu/+source/memcached:upstream-bump-1.5.10 into ubuntu/+source/memcached:ubuntu/devel

[Robie Basak]

This includes fixes for some issues which were causing build time test failures, preventing memcached from migrating to the release pocket. Thanks to upstream working closely with us, all the fixes are released upstream, so we just pull in the latest and it works.

After Debian takes this we should be able to sync.

[Robie Basak (racb)]

A PPA build should be available in ppa:racb/experimental shortly.

[Christian Ehrhardt  (paelzer)]

Hi,
a few things inline - mostly suggestions for the changelog.

The bump itself seems correct to me - content change wise.
The md5sum of the upstream download matches:
$ md5sum memcached-1.5.10.tar.gz memcached_1.5.10.orig.tar.gz
8462616b554183a75845b03c56837cca memcached-1.5.10.tar.gz
8462616b554183a75845b03c56837cca memcached_1.5.10.orig.tar.gz

From:
http://www.memcached.org/files/memcached-1.5.10.tar.gz
https://launchpad.net/~racb/+archive/ubuntu/experimental/+sourcefiles/memcached/1.5.10-0ubuntu1~ppa1/memcached_1.5.10.orig.tar.gz

No other functional changes required.

The inline comments are all style-questions which you can decide either way.
I'll do some testing before a full +1

[Christian Ehrhardt  (paelzer)]

I copied from your ppa that was identical to the proposed changes.
Testing from that ...

qa tests:
- I ran against the old version in cosmic 1.5.6-0ubuntu1 to know which might be known issues and if the test is repeatable
- of these memcdump had a fail, but all others worked
- after upgrading to the ppa version (upgrade worked) I reran the tests
- all tests that worked still work (no change on memcdump)

Running test: './test-memcached.py' distro: 'Ubuntu 18.10' kernel: '4.17.0-6.7 (Ubuntu 4.17.0-6.7-generic 4.17.9)' arch: 'amd64' uid: 0/0 SUDO_USER: 'ubuntu')
Skipping private tests
test_add (__main__.MemcachedTest)
Test adding data ... ok
test_cve_2011_4971 (__main__.MemcachedTest)
Test CVE-2011-4971 ... ok
test_default_tcp (__main__.MemcachedTest)
Test that memcached is listening on tcp port by default ... ok
test_default_udp (__main__.MemcachedTest)
Test that memcached is listening on udp port by default ... ok
test_memccapable (__main__.MemcachedTest)
Test memccapable ... ok
test_memccat (__main__.MemcachedTest)
Test memccat ... ok
test_memcdump (__main__.MemcachedTest)
Test memcdump ... FAIL
test_memcrm (__main__.MemcachedTest)
Test memcrm ... ok
test_memcstat (__main__.MemcachedTest)
Test memcstat ... ok
test_sample_data (__main__.MemcachedTest)
Test sample data ... ok
test_set (__main__.MemcachedTest)
Test setting data ... ok

[Christian Ehrhardt  (paelzer)]

Autopkgtests are enqueued, will check results after lunch.

[Christian Ehrhardt  (paelzer)]

Autopkgtests are also good:
flask-limiter/1.0.1-1
gnocchi/4.2.4-0ubuntu3
memcached/1.5.10-0ubuntu1~ppa1
pgmemcache/2.3.0-4
python-limits/1.3-1

That said, code good, changelog ok (up to you to adapt my suggestions) and tests good - +1 on the MP

review: Approve

[Christian Ehrhardt  (paelzer)]

FYI - test link https://bileto.ubuntu.com/excuses/3352/cosmic.html

diff --git a/INSTALL b/INSTALL
 new file mode 100644
index 0000000..2099840
--- /dev/null
+++ b/INSTALL
@@ -0,0 +1,370 @@
+Installation Instructions
+*************************
+
+Copyright (C) 1994-1996, 1999-2002, 2004-2013 Free Software Foundation,
+Inc.
+
+   Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.  This file is offered as-is,
+without warranty of any kind.
+
+Basic Installation
+==================
+
+   Briefly, the shell command `./configure && make && make install'
+should configure, build, and install this package.  The following
+more-detailed instructions are generic; see the `README' file for
+instructions specific to this package.  Some packages provide this
+`INSTALL' file but do not implement all of the features documented
+below.  The lack of an optional feature in a given package is not
+necessarily a bug.  More recommendations for GNU packages can be found
+in *note Makefile Conventions: (standards)Makefile Conventions.
+
+   The `configure' shell script attempts to guess correct values for
+various system-dependent variables used during compilation.  It uses
+those values to create a `Makefile' in each directory of the package.
+It may also create one or more `.h' files containing system-dependent
+definitions.  Finally, it creates a shell script `config.status' that
+you can run in the future to recreate the current configuration, and a
+file `config.log' containing compiler output (useful mainly for
+debugging `configure').
+
+   It can also use an optional file (typically called `config.cache'
+and enabled with `--cache-file=config.cache' or simply `-C') that saves
+the results of its tests to speed up reconfiguring.  Caching is
+disabled by default to prevent problems with accidental use of stale
+cache files.
+
+   If you need to do unusual things to compile the package, please try
+to figure out how `configure' could check whether to do them, and mail
+diffs or instructions to the address given in the `README' so they can
+be considered for the next release.  If you are using the cache, and at
+some point `config.cache' contains results you don't want to keep, you
+may remove or edit it.
+
+   The file `configure.ac' (or `configure.in') is used to create
+`configure' by a program called `autoconf'.  You need `configure.ac' if
+you want to change it or regenerate `configure' using a newer version
+of `autoconf'.
+
+   The simplest way to compile this package is:
+
+  1. `cd' to the directory containing the package's source code and type
+     `./configure' to configure the package for your system.
+
+     Running `configure' might take a while.  While running, it prints
+     some messages telling which features it is checking for.
+
+  2. Type `make' to compile the package.
+
+  3. Optionally, type `make check' to run any self-tests that come with
+     the package, generally using the just-built uninstalled binaries.
+
+  4. Type `make install' to install the programs and any data files and
+     documentation.  When installing into a prefix owned by root, it is
+     recommended that the package be configured and built as a regular
+     user, and only the `make install' phase executed with root
+     privileges.
+
+  5. Optionally, type `make installcheck' to repeat any self-tests, but
+     this time using the binaries in their final installed location.
+     This target does not install anything.  Running this target as a
+     regular user, particularly if the prior `make install' required
+     root privileges, verifies that the installation completed
+     correctly.
+
+  6. You can remove the program binaries and object files from the
+     source code directory by typing `make clean'.  To also remove the
+     files that `configure' created (so you can compile the package for
+     a different kind of computer), type `make distclean'.  There is
+     also a `make maintainer-clean' target, but that is intended mainly
+     for the package's developers.  If you use it, you may have to get
+     all sorts of other programs in order to regenerate files that came
+     with the distribution.
+
+  7. Often, you can also type `make uninstall' to remove the installed
+     files again.  In practice, not all packages have tested that
+     uninstallation works correctly, even though it is required by the
+     GNU Coding Standards.
+
+  8. Some packages, particularly those that use Automake, provide `make
+     distcheck', which can by used by developers to test that all other
+     targets like `make install' and `make uninstall' work correctly.
+     This target is generally not run by end users.
+
+Compilers and Options
+=====================
+
+   Some systems require unusual options for compilation or linking that
+the `configure' script does not know about.  Run `./configure --help'
+for details on some of the pertinent environment variables.
+
+   You can give `configure' initial values for configuration parameters
+by setting variables in the command line or in the environment.  Here
+is an example:
+
+     ./configure CC=c99 CFLAGS=-g LIBS=-lposix
+
+   *Note Defining Variables::, for more details.
+
+Compiling For Multiple Architectures
+====================================
+
+   You can compile the package for more than one kind of computer at the
+same time, by placing the object files for each architecture in their
+own directory.  To do this, you can use GNU `make'.  `cd' to the
+directory where you want the object files and executables to go and run
+the `configure' script.  `configure' automatically checks for the
+source code in the directory that `configure' is in and in `..'.  This
+is known as a "VPATH" build.
+
+   With a non-GNU `make', it is safer to compile the package for one
+architecture at a time in the source code directory.  After you have
+installed the package for one architecture, use `make distclean' before
+reconfiguring for another architecture.
+
+   On MacOS X 10.5 and later systems, you can create libraries and
+executables that work on multiple system types--known as "fat" or
+"universal" binaries--by specifying multiple `-arch' options to the
+compiler but only a single `-arch' option to the preprocessor.  Like
+this:
+
+     ./configure CC="gcc -arch i386 -arch x86_64 -arch ppc -arch ppc64" \
+                 CXX="g++ -arch i386 -arch x86_64 -arch ppc -arch ppc64" \
+                 CPP="gcc -E" CXXCPP="g++ -E"
+
+   This is not guaranteed to produce working output in all cases, you
+may have to build one architecture at a time and combine the results
+using the `lipo' tool if you have problems.
+
+Installation Names
+==================
+
+   By default, `make install' installs the package's commands under
+`/usr/local/bin', include files under `/usr/local/include', etc.  You
+can specify an installation prefix other than `/usr/local' by giving
+`configure' the option `--prefix=PREFIX', where PREFIX must be an
+absolute file name.
+
+   You can specify separate installation prefixes for
+architecture-specific files and architecture-independent files.  If you
+pass the option `--exec-prefix=PREFIX' to `configure', the package uses
+PREFIX as the prefix for installing programs and libraries.
+Documentation and other data files still use the regular prefix.
+
+   In addition, if you use an unusual directory layout you can give
+options like `--bindir=DIR' to specify different values for particular
+kinds of files.  Run `configure --help' for a list of the directories
+you can set and what kinds of files go in them.  In general, the
+default for these options is expressed in terms of `${prefix}', so that
+specifying just `--prefix' will affect all of the other directory
+specifications that were not explicitly provided.
+
+   The most portable way to affect installation locations is to pass the
+correct locations to `configure'; however, many packages provide one or
+both of the following shortcuts of passing variable assignments to the
+`make install' command line to change installation locations without
+having to reconfigure or recompile.
+
+   The first method involves providing an override variable for each
+affected directory.  For example, `make install
+prefix=/alternate/directory' will choose an alternate location for all
+directory configuration variables that were expressed in terms of
+`${prefix}'.  Any directories that were specified during `configure',
+but not in terms of `${prefix}', must each be overridden at install
+time for the entire installation to be relocated.  The approach of
+makefile variable overrides for each directory variable is required by
+the GNU Coding Standards, and ideally causes no recompilation.
+However, some platforms have known limitations with the semantics of
+shared libraries that end up requiring recompilation when using this
+method, particularly noticeable in packages that use GNU Libtool.
+
+   The second method involves providing the `DESTDIR' variable.  For
+example, `make install DESTDIR=/alternate/directory' will prepend
+`/alternate/directory' before all installation names.  The approach of
+`DESTDIR' overrides is not required by the GNU Coding Standards, and
+does not work on platforms that have drive letters.  On the other hand,
+it does better at avoiding recompilation issues, and works well even
+when some directory options were not specified in terms of `${prefix}'
+at `configure' time.
+
+Optional Features
+=================
+
+   If the package supports it, you can cause programs to be installed
+with an extra prefix or suffix on their names by giving `configure' the
+option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
+
+   Some packages pay attention to `--enable-FEATURE' options to
+`configure', where FEATURE indicates an optional part of the package.
+They may also pay attention to `--with-PACKAGE' options, where PACKAGE
+is something like `gnu-as' or `x' (for the X Window System).  The
+`README' should mention any `--enable-' and `--with-' options that the
+package recognizes.
+
+   For packages that use the X Window System, `configure' can usually
+find the X include and library files automatically, but if it doesn't,
+you can use the `configure' options `--x-includes=DIR' and
+`--x-libraries=DIR' to specify their locations.
+
+   Some packages offer the ability to configure how verbose the
+execution of `make' will be.  For these packages, running `./configure
+--enable-silent-rules' sets the default to minimal output, which can be
+overridden with `make V=1'; while running `./configure
+--disable-silent-rules' sets the default to verbose, which can be
+overridden with `make V=0'.
+
+Particular systems
+==================
+
+   On HP-UX, the default C compiler is not ANSI C compatible.  If GNU
+CC is not installed, it is recommended to use the following options in
+order to use an ANSI C compiler:
+
+     ./configure CC="cc -Ae -D_XOPEN_SOURCE=500"
+
+and if that doesn't work, install pre-built binaries of GCC for HP-UX.
+
+   HP-UX `make' updates targets which have the same time stamps as
+their prerequisites, which makes it generally unusable when shipped
+generated files such as `configure' are involved.  Use GNU `make'
+instead.
+
+   On OSF/1 a.k.a. Tru64, some versions of the default C compiler cannot
+parse its `<wchar.h>' header file.  The option `-nodtk' can be used as
+a workaround.  If GNU CC is not installed, it is therefore recommended
+to try
+
+     ./configure CC="cc"
+
+and if that doesn't work, try
+
+     ./configure CC="cc -nodtk"
+
+   On Solaris, don't put `/usr/ucb' early in your `PATH'.  This
+directory contains several dysfunctional programs; working variants of
+these programs are available in `/usr/bin'.  So, if you need `/usr/ucb'
+in your `PATH', put it _after_ `/usr/bin'.
+
+   On Haiku, software installed for all users goes in `/boot/common',
+not `/usr/local'.  It is recommended to use the following options:
+
+     ./configure --prefix=/boot/common
+
+Specifying the System Type
+==========================
+
+   There may be some features `configure' cannot figure out
+automatically, but needs to determine by the type of machine the package
+will run on.  Usually, assuming the package is built to be run on the
+_same_ architectures, `configure' can figure that out, but if it prints
+a message saying it cannot guess the machine type, give it the
+`--build=TYPE' option.  TYPE can either be a short name for the system
+type, such as `sun4', or a canonical name which has the form:
+
+     CPU-COMPANY-SYSTEM
+
+where SYSTEM can have one of these forms:
+
+     OS
+     KERNEL-OS
+
+   See the file `config.sub' for the possible values of each field.  If
+`config.sub' isn't included in this package, then this package doesn't
+need to know the machine type.
+
+   If you are _building_ compiler tools for cross-compiling, you should
+use the option `--target=TYPE' to select the type of system they will
+produce code for.
+
+   If you want to _use_ a cross compiler, that generates code for a
+platform different from the build platform, you should specify the
+"host" platform (i.e., that on which the generated programs will
+eventually be run) with `--host=TYPE'.
+
+Sharing Defaults
+================
+
+   If you want to set default values for `configure' scripts to share,
+you can create a site shell script called `config.site' that gives
+default values for variables like `CC', `cache_file', and `prefix'.
+`configure' looks for `PREFIX/share/config.site' if it exists, then
+`PREFIX/etc/config.site' if it exists.  Or, you can set the
+`CONFIG_SITE' environment variable to the location of the site script.
+A warning: not all `configure' scripts look for a site script.
+
+Defining Variables
+==================
+
+   Variables not defined in a site shell script can be set in the
+environment passed to `configure'.  However, some packages may run
+configure again during the build, and the customized values of these
+variables may be lost.  In order to avoid this problem, you should set
+them in the `configure' command line, using `VAR=value'.  For example:
+
+     ./configure CC=/usr/local2/bin/gcc
+
+causes the specified `gcc' to be used as the C compiler (unless it is
+overridden in the site shell script).
+
+Unfortunately, this technique does not work for `CONFIG_SHELL' due to
+an Autoconf limitation.  Until the limitation is lifted, you can use
+this workaround:
+
+     CONFIG_SHELL=/bin/bash ./configure CONFIG_SHELL=/bin/bash
+
+`configure' Invocation
+======================
+
+   `configure' recognizes the following options to control how it
+operates.
+
+`--help'
+`-h'
+     Print a summary of all of the options to `configure', and exit.
+
+`--help=short'
+`--help=recursive'
+     Print a summary of the options unique to this package's
+     `configure', and exit.  The `short' variant lists options used
+     only in the top level, while the `recursive' variant lists options
+     also present in any nested packages.
+
+`--version'
+`-V'
+     Print the version of Autoconf used to generate the `configure'
+     script, and exit.
+
+`--cache-file=FILE'
+     Enable the cache: use and save the results of the tests in FILE,
+     traditionally `config.cache'.  FILE defaults to `/dev/null' to
+     disable caching.
+
+`--config-cache'
+`-C'
+     Alias for `--cache-file=config.cache'.
+
+`--quiet'
+`--silent'
+`-q'
+     Do not print messages saying which checks are being made.  To
+     suppress all normal output, redirect it to `/dev/null' (any error
+     messages will still be shown).
+
+`--srcdir=DIR'
+     Look for the package's source code in directory DIR.  Usually
+     `configure' can determine that directory automatically.
+
+`--prefix=DIR'
+     Use DIR as the installation prefix.  *note Installation Names::
+     for more details, including other options available for fine-tuning
+     the installation locations.
+
+`--no-create'
+`-n'
+     Run the configure checks, but stop before creating any output
+     files.
+
+`configure' also accepts some other, not widely useful, options.  Run
+`configure --help' for more details.
diff --git a/Makefile.in b/Makefile.in
index 966b4d7..c125ace 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -327,8 +327,8 @@ CTAGS = ctags
 CSCOPE = cscope
 DIST_SUBDIRS = $(SUBDIRS)
 am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/config.h.in AUTHORS \
-	COPYING ChangeLog NEWS compile config.guess config.sub depcomp \
-	install-sh missing
+	COPYING ChangeLog INSTALL NEWS compile config.guess config.sub \
+	depcomp install-sh missing
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 distdir = $(PACKAGE)-$(VERSION)
 top_distdir = $(distdir)
diff --git a/README.md b/README.md
index 935e4cd..e330fbe 100644
--- a/README.md
+++ b/README.md
@@ -18,8 +18,8 @@ list to ask questions, github issues aren't seen by everyone!
 ## Dependencies
 
 * libevent, http://www.monkey.org/~provos/libevent/ (libevent-dev)
-* libseccomp, (optional, linux) - enables process restrictions for better
-  security.
+* libseccomp, (optional, experimental, linux) - enables process restrictions for
+  better security. Tested only on x86_64 architectures.
 
 ## Environment
 
diff --git a/config.h.in b/config.h.in
index 9638dfa..3f3d42d 100644
--- a/config.h.in
+++ b/config.h.in
@@ -1,5 +1,8 @@
 /* config.h.in.  Generated from configure.ac by autoheader.  */
 
+/* Set to nonzero if you want to enable ARMv8 crc32 */
+#undef ARM_CRC32
+
 /* Set to nonzero if you want to include DTRACE */
 #undef ENABLE_DTRACE
 
@@ -15,7 +18,7 @@
 /* machine is littleendian */
 #undef ENDIAN_LITTLE
 
-/* Set to nonzero if you want to enable extstorextstore */
+/* Set to nonzero if you want to enable extstore */
 #undef EXTSTORE
 
 /* Define to 1 if support accept4 */
@@ -66,6 +69,9 @@
 /* Set to nonzero if your SASL implementation supports SASL_CB_GETCONF */
 #undef HAVE_SASL_CB_GETCONF
 
+/* Set to nonzero if your SASL implementation supports SASL_CB_GETCONFPATH */
+#undef HAVE_SASL_CB_GETCONFPATH
+
 /* Define to 1 if you have the <sasl/sasl.h> header file. */
 #undef HAVE_SASL_SASL_H
 
diff --git a/configure b/configure
index e479e60..9ccb4dd 100755
--- a/configure
+++ b/configure
@@ -1,6 +1,6 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.69 for memcached 1.5.6.
+# Generated by GNU Autoconf 2.69 for memcached 1.5.10.
 #
 # Report bugs to <[e-mail]>.
 #
@@ -580,8 +580,8 @@ MAKEFLAGS=
 # Identity of this package.
 PACKAGE_NAME='memcached'
 PACKAGE_TARNAME='memcached'
-PACKAGE_VERSION='1.5.6'
-PACKAGE_STRING='memcached 1.5.6'
+PACKAGE_VERSION='1.5.10'
+PACKAGE_STRING='memcached 1.5.10'
 PACKAGE_BUGREPORT='[e-mail]'
 PACKAGE_URL=''
 
@@ -643,6 +643,8 @@ PROFILER
 PROFILER_LDFLAGS
 ENABLE_SASL
 DTRACEFLAGS
+ENABLE_ARM_CRC32_FALSE
+ENABLE_ARM_CRC32_TRUE
 ENABLE_EXTSTORE_FALSE
 ENABLE_EXTSTORE_TRUE
 ENABLE_SASL_FALSE
@@ -751,6 +753,7 @@ ac_user_opts='
 enable_option_checking
 enable_silent_rules
 enable_dependency_tracking
+enable_arm_crc32
 enable_extstore
 enable_seccomp
 enable_sasl
@@ -1320,7 +1323,7 @@ if test "$ac_init_help" = "long"; then
   # Omit some internal or obsolete options to make the list less imposing.
   # This message is too long to be a string in the A/UX 3.1 sh.
   cat <<_ACEOF
-\`configure' configures memcached 1.5.6 to adapt to many kinds of systems.
+\`configure' configures memcached 1.5.10 to adapt to many kinds of systems.
 
 Usage: $0 [OPTION]... [VAR=VALUE]...
 
@@ -1391,7 +1394,7 @@ fi
 
 if test -n "$ac_init_help"; then
   case $ac_init_help in
-     short | recursive ) echo "Configuration of memcached 1.5.6:";;
+     short | recursive ) echo "Configuration of memcached 1.5.10:";;
    esac
   cat <<\_ACEOF
 
@@ -1405,8 +1408,9 @@ Optional Features:
                           do not reject slow dependency extractors
   --disable-dependency-tracking
                           speeds up one-time build
+  --enable-arm-crc32      Enable ARMv8 CRC32 instructions
   --enable-extstore       Enable external storage EXPERIMENTAL
-  --enable-seccomp        Enable seccomp restrictions
+  --enable-seccomp        Enable seccomp restrictions EXPERIMENTAL
   --enable-sasl           Enable SASL authentication
   --enable-sasl-pwdb      Enable plaintext password db
   --enable-dtrace         Enable dtrace probes
@@ -1495,7 +1499,7 @@ fi
 test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
-memcached configure 1.5.6
+memcached configure 1.5.10
 generated by GNU Autoconf 2.69
 
 Copyright (C) 2012 Free Software Foundation, Inc.
@@ -1964,7 +1968,7 @@ cat >config.log <<_ACEOF
 This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
 
-It was created by memcached $as_me 1.5.6, which was
+It was created by memcached $as_me 1.5.10, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   $ $0 $@
@@ -2899,7 +2903,7 @@ fi
 
 # Define the identity of the package.
  PACKAGE='memcached'
- VERSION='1.5.6'
+ VERSION='1.5.10'
 
 
 cat >>confdefs.h <<_ACEOF
@@ -4701,6 +4705,12 @@ fi
 
 
 
+# Check whether --enable-arm_crc32 was given.
+if test "${enable_arm_crc32+set}" = set; then :
+  enableval=$enable_arm_crc32;
+fi
+
+
 # Check whether --enable-extstore was given.
 if test "${enable_extstore+set}" = set; then :
   enableval=$enable_extstore;
@@ -4733,6 +4743,8 @@ fi
 
 
 
+
+
 for ac_header in sasl/sasl.h
 do :
   ac_fn_c_check_header_mongrel "$LINENO" "sasl/sasl.h" "ac_cv_header_sasl_sasl_h" "$ac_includes_default"
@@ -4784,6 +4796,43 @@ $as_echo "#define HAVE_SASL_CB_GETCONF 1" >>confdefs.h
 fi
 
 
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SASL_CB_GETCONFPATH" >&5
+$as_echo_n "checking for SASL_CB_GETCONFPATH... " >&6; }
+if ${ac_cv_c_sasl_cb_getconfpath+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#include <sasl/sasl.h>
+
+int
+main ()
+{
+
+unsigned long val = SASL_CB_GETCONFPATH;
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+   ac_cv_c_sasl_cb_getconfpath=yes
+else
+   ac_cv_c_sasl_cb_getconfpath=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_sasl_cb_getconfpath" >&5
+$as_echo "$ac_cv_c_sasl_cb_getconfpath" >&6; }
+    if test "$ac_cv_c_sasl_cb_getconfpath" = "yes"; then :
+
+$as_echo "#define HAVE_SASL_CB_GETCONFPATH 1" >>confdefs.h
+
+fi
+
+
 $as_echo "#define ENABLE_SASL 1" >>confdefs.h
 
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing sasl_server_init" >&5
@@ -4929,6 +4978,12 @@ $as_echo "#define EXTSTORE 1" >>confdefs.h
 
 fi
 
+if test "x$enable_arm_crc32" = "xyes"; then
+
+$as_echo "#define ARM_CRC32 1" >>confdefs.h
+
+fi
+
  if test "$build_dtrace" = "yes"; then
   BUILD_DTRACE_TRUE=
   BUILD_DTRACE_FALSE='#'
@@ -4961,6 +5016,14 @@ else
   ENABLE_EXTSTORE_FALSE=
 fi
 
+ if test "$enable_arm_crc32" = "yes"; then
+  ENABLE_ARM_CRC32_TRUE=
+  ENABLE_ARM_CRC32_FALSE='#'
+else
+  ENABLE_ARM_CRC32_TRUE='#'
+  ENABLE_ARM_CRC32_FALSE=
+fi
+
 
 
 
@@ -6203,6 +6266,7 @@ else
 
 #include <stdlib.h>
 #include <inttypes.h>
+#pragma GCC optimize ("O0")
 
 int
 main ()
@@ -6292,6 +6356,7 @@ have_gcc_64atomics=no
 $as_echo_n "checking for GCC 64bit atomics... " >&6; }
 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
+#include <inttypes.h>
 
 int
 main ()
@@ -6739,6 +6804,10 @@ if test -z "${ENABLE_EXTSTORE_TRUE}" && test -z "${ENABLE_EXTSTORE_FALSE}"; then
   as_fn_error $? "conditional \"ENABLE_EXTSTORE\" was never defined.
 Usually this means the macro was only invoked conditionally." "$LINENO" 5
 fi
+if test -z "${ENABLE_ARM_CRC32_TRUE}" && test -z "${ENABLE_ARM_CRC32_FALSE}"; then
+  as_fn_error $? "conditional \"ENABLE_ARM_CRC32\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
 if test -z "${BUILD_SOLARIS_PRIVS_TRUE}" && test -z "${BUILD_SOLARIS_PRIVS_FALSE}"; then
   as_fn_error $? "conditional \"BUILD_SOLARIS_PRIVS\" was never defined.
 Usually this means the macro was only invoked conditionally." "$LINENO" 5
@@ -7156,7 +7225,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
 # report actual input values of CONFIG_FILES etc. instead of their
 # values after options handling.
 ac_log="
-This file was extended by memcached $as_me 1.5.6, which was
+This file was extended by memcached $as_me 1.5.10, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
@@ -7222,7 +7291,7 @@ _ACEOF
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
 ac_cs_version="\\
-memcached config.status 1.5.6
+memcached config.status 1.5.10
 configured by $0, generated by GNU Autoconf 2.69,
   with options \\"\$ac_cs_config\\"
 
diff --git a/configure.ac b/configure.ac
index 9f05cfa..abcb8ae 100644
--- a/configure.ac
+++ b/configure.ac
@@ -82,11 +82,14 @@ fi
 AM_PROG_CC_C_O
 AC_PROG_INSTALL
 
+AC_ARG_ENABLE(arm_crc32,
+  [AS_HELP_STRING([--enable-arm-crc32], [Enable ARMv8 CRC32 instructions])])
+
 AC_ARG_ENABLE(extstore,
   [AS_HELP_STRING([--enable-extstore], [Enable external storage EXPERIMENTAL ])])
 
 AC_ARG_ENABLE(seccomp,
-  [AS_HELP_STRING([--enable-seccomp],[Enable seccomp restrictions])])
+  [AS_HELP_STRING([--enable-seccomp],[Enable seccomp restrictions EXPERIMENTAL])])
 
 AC_ARG_ENABLE(sasl,
   [AS_HELP_STRING([--enable-sasl],[Enable SASL authentication])])
@@ -122,9 +125,33 @@ unsigned long val = SASL_CB_GETCONF;
                      [Set to nonzero if your SASL implementation supports SASL_CB_GETCONF])])
 ])
 
+dnl **********************************************************************
+dnl DETECT_SASL_CB_GETCONFPATH
+dnl
+dnl check if we can use SASL_CB_GETCONFPATH
+dnl **********************************************************************
+AC_DEFUN([AC_C_DETECT_SASL_CB_GETCONFPATH],
+[
+    AC_CACHE_CHECK([for SASL_CB_GETCONFPATH],
+        [ac_cv_c_sasl_cb_getconfpath],
+        [AC_TRY_COMPILE(
+            [
+#include <sasl/sasl.h>
+            ], [
+unsigned long val = SASL_CB_GETCONFPATH;
+            ],
+            [ ac_cv_c_sasl_cb_getconfpath=yes ],
+            [ ac_cv_c_sasl_cb_getconfpath=no ])
+        ])
+    AS_IF([test "$ac_cv_c_sasl_cb_getconfpath" = "yes"],
+          [AC_DEFINE([HAVE_SASL_CB_GETCONFPATH], 1,
+                     [Set to nonzero if your SASL implementation supports SASL_CB_GETCONFPATH])])
+])
+
 AC_CHECK_HEADERS([sasl/sasl.h])
 if test "x$enable_sasl" = "xyes"; then
   AC_C_DETECT_SASL_CB_GETCONF
+  AC_C_DETECT_SASL_CB_GETCONFPATH
   AC_DEFINE([ENABLE_SASL],1,[Set to nonzero if you want to include SASL])
   AC_SEARCH_LIBS([sasl_server_init], [sasl2 sasl], [],
     [
@@ -160,13 +187,18 @@ if test "x$enable_dtrace" = "xyes"; then
 fi
 
 if test "x$enable_extstore" = "xyes"; then
-    AC_DEFINE([EXTSTORE],1,[Set to nonzero if you want to enable extstorextstore])
+    AC_DEFINE([EXTSTORE],1,[Set to nonzero if you want to enable extstore])
+fi
+
+if test "x$enable_arm_crc32" = "xyes"; then
+    AC_DEFINE([ARM_CRC32],1,[Set to nonzero if you want to enable ARMv8 crc32])
 fi
 
 AM_CONDITIONAL([BUILD_DTRACE],[test "$build_dtrace" = "yes"])
 AM_CONDITIONAL([DTRACE_INSTRUMENT_OBJ],[test "$dtrace_instrument_obj" = "yes"])
 AM_CONDITIONAL([ENABLE_SASL],[test "$enable_sasl" = "yes"])
 AM_CONDITIONAL([ENABLE_EXTSTORE],[test "$enable_extstore" = "yes"])
+AM_CONDITIONAL([ENABLE_ARM_CRC32],[test "$enable_arm_crc32" = "yes"])
 
 AC_SUBST(DTRACE)
 AC_SUBST(DTRACEFLAGS)
@@ -490,6 +522,8 @@ AC_CHECK_FUNCS(clock_gettime)
 AC_CHECK_FUNCS([accept4], [AC_DEFINE(HAVE_ACCEPT4, 1, [Define to 1 if support accept4])])
 AC_CHECK_FUNCS([getopt_long], [AC_DEFINE(HAVE_GETOPT_LONG, 1, [Define to 1 if support getopt_long])])
 
+dnl Need to disable opt for alignment check. GCC is too clever and turns this
+dnl into wide stores and no cmp under O2.
 AC_DEFUN([AC_C_ALIGNMENT],
 [AC_CACHE_CHECK(for alignment, ac_cv_c_alignment,
 [
@@ -497,6 +531,7 @@ AC_DEFUN([AC_C_ALIGNMENT],
     [AC_LANG_PROGRAM([
 #include <stdlib.h>
 #include <inttypes.h>
+#pragma GCC optimize ("O0")
     ], [
        char *buf = malloc(32);
 
@@ -551,7 +586,8 @@ dnl Check for usage of 64bit atomics
 dnl 32bit systems shouldn't have these.
 have_gcc_64atomics=no
 AC_MSG_CHECKING(for GCC 64bit atomics)
-AC_TRY_LINK([],[
+AC_TRY_LINK([#include <inttypes.h>
+   ],[
   uint64_t a;
   uint64_t b;
   b = __sync_add_and_fetch(&a, 1);
diff --git a/crawler.c b/crawler.c
index 9c81bba..a1a5ead 100644
--- a/crawler.c
+++ b/crawler.c
@@ -218,7 +218,6 @@ static void crawler_expired_eval(crawler_module_t *cm, item *search, uint32_t hv
 #endif
         do_item_unlink_nolock(search, hv);
         do_item_remove(search);
-        assert(search->slabs_clsid == 0);
     } else {
         s->seen++;
         refcount_decr(search);
@@ -533,6 +532,14 @@ static int do_lru_crawler_start(uint32_t id, uint32_t remaining) {
         if (remaining == LRU_CRAWLER_CAP_REMAINING) {
             remaining = do_get_lru_size(sid);
         }
+        /* Values for remaining:
+         * remaining = 0
+         * - scan all elements, until a NULL is reached
+         * - if empty, NULL is reached right away
+         * remaining = n + 1
+         * - first n elements are parsed (or until a NULL is reached)
+         */
+        if (remaining) remaining++;
         crawlers[sid].remaining = remaining;
         crawlers[sid].slabs_clsid = sid;
         crawlers[sid].reclaimed = 0;
diff --git a/crc32c.c b/crc32c.c
index 13deee2..a4296a7 100644
--- a/crc32c.c
+++ b/crc32c.c
@@ -40,6 +40,10 @@
 #include <stdint.h>
 #include <unistd.h>
 #include <pthread.h>
+#include "config.h"
+#if defined(__linux__) && defined(__aarch64__)
+#include <sys/auxv.h>
+#endif
 #include "crc32c.h"
 
 /* CRC-32C (iSCSI) polynomial in reversed bit order. */
@@ -109,6 +113,60 @@ static uint32_t crc32c_sw(uint32_t crci, const void *buf, size_t len)
     return (uint32_t)crc ^ 0xffffffff;
 }
 
+/* Hardware CRC support for aarch64 platform */
+#if defined(__linux__) && defined(__aarch64__) && defined(ARM_CRC32)
+
+#define CRC32CX(crc, value) __asm__("crc32cx %w[c], %w[c], %x[v]":[c]"+r"(crc):[v]"r"(+value))
+#define CRC32CW(crc, value) __asm__("crc32cw %w[c], %w[c], %w[v]":[c]"+r"(crc):[v]"r"(+value))
+#define CRC32CH(crc, value) __asm__("crc32ch %w[c], %w[c], %w[v]":[c]"+r"(crc):[v]"r"(+value))
+#define CRC32CB(crc, value) __asm__("crc32cb %w[c], %w[c], %w[v]":[c]"+r"(crc):[v]"r"(+value))
+
+#ifndef HWCAP_CRC32
+#define HWCAP_CRC32             (1 << 7)
+#endif /* HWCAP for crc32 */
+
+static uint32_t crc32c_hw_aarch64(uint32_t crc, const void* buf, size_t len)
+{
+        const uint8_t* p_buf = buf;
+        uint64_t crc64bit = crc;
+        for (size_t i = 0; i < len / sizeof(uint64_t); i++) {
+                CRC32CX(crc64bit, *(uint64_t*) p_buf);
+                p_buf += sizeof(uint64_t);
+        }
+
+        uint32_t crc32bit = (uint32_t) crc64bit;
+        len &= sizeof(uint64_t) - 1;
+        switch (len) {
+        case 7:
+                CRC32CB(crc32bit, *p_buf++);
+        case 6:
+                CRC32CH(crc32bit, *(uint16_t*) p_buf);
+                p_buf += 2;
+        case 4:
+                CRC32CW(crc32bit, *(uint32_t*) p_buf);
+                break;
+        case 3:
+                CRC32CB(crc32bit, *p_buf++);
+        case 2:
+                CRC32CH(crc32bit, *(uint16_t*) p_buf);
+                break;
+        case 5:
+                CRC32CW(crc32bit, *(uint32_t*) p_buf);
+                p_buf += 4;
+        case 1:
+                CRC32CB(crc32bit, *p_buf);
+                break;
+        case 0:
+                break;
+        }
+
+        return crc32bit;
+}
+#endif
+
+/* Apply if the platform is intel */
+#if defined(__X86_64__)||defined(__x86_64__)||defined(__ia64__)
+
 /* Multiply a matrix times a vector over the Galois field of two elements,
    GF(2).  Each element is a bit in an unsigned integer.  mat must have at
    least as many entries as the power of two for most significant one bit in
@@ -329,15 +387,27 @@ static uint32_t crc32c_hw(uint32_t crc, const void *buf, size_t len)
         (have) = (ecx >> 20) & 1; \
     } while (0)
 
+#endif
 /* Compute a CRC-32C.  If the crc32 instruction is available, use the hardware
    version.  Otherwise, use the software version. */
 void crc32c_init(void) {
+    #if defined(__X86_64__)||defined(__x86_64__)||defined(__ia64__)
     int sse42;
-
     SSE42(sse42);
+
     if (sse42) {
         crc32c = crc32c_hw;
-    } else {
+    } else
+    #endif
+    /* Check if CRC instructions supported by aarch64 */
+    #if defined(__linux__) && defined(__aarch64__) && defined(ARM_CRC32)
+    unsigned long hwcap = getauxval(AT_HWCAP);
+
+    if (hwcap & HWCAP_CRC32) {
+        crc32c = crc32c_hw_aarch64;
+    } else
+    #endif
+    {
         crc32c = crc32c_sw;
     }
 }
diff --git a/debian/changelog b/debian/changelog
index 43c90a2..1397f89 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,11 @@
+memcached (1.5.10-0ubuntu1) cosmic; urgency=medium
+
+  * New upstream release.
+  * Includes fixes for various failures on various architectures
+    (LP: #1780838).
+
+ -- Robie Basak <[e-mail]>  Mon, 13 Aug 2018 13:10:37 +0100
+
 memcached (1.5.6-1) unstable; urgency=medium
 
   * New upstream release
diff --git a/debian/control b/debian/control
index 72e948f..2c63ea0 100644
--- a/debian/control
+++ b/debian/control
@@ -1,7 +1,8 @@
 Source: memcached
 Section: web
 Priority: optional
-Maintainer: Guillaume Delacour <[e-mail]>
+Maintainer: Ubuntu Developers <[e-mail]>
+XSBC-Original-Maintainer: Guillaume Delacour <[e-mail]>
 Build-Depends: debhelper (>> 10), libevent-dev, libsasl2-dev, adduser,
                autotools-dev, dh-autoreconf
 Homepage: http://www.memcached.org/
diff --git a/doc/Makefile b/doc/Makefile
index 0337680..49cce71 100644
--- a/doc/Makefile
+++ b/doc/Makefile
@@ -191,10 +191,10 @@ OBJEXT = o
 PACKAGE = memcached
 PACKAGE_BUGREPORT = [e-mail]
 PACKAGE_NAME = memcached
-PACKAGE_STRING = memcached 1.5.6
+PACKAGE_STRING = memcached 1.5.10
 PACKAGE_TARNAME = memcached
 PACKAGE_URL = 
-PACKAGE_VERSION = 1.5.6
+PACKAGE_VERSION = 1.5.10
 PATH_SEPARATOR = :
 PROFILER = /usr/bin/gcov
 PROFILER_FLAGS = -fprofile-arcs -ftest-coverage
@@ -202,7 +202,7 @@ PROFILER_LDFLAGS = -lgcov
 SET_MAKE = 
 SHELL = /bin/bash
 STRIP = 
-VERSION = 1.5.6
+VERSION = 1.5.10
 XML2RFC = /usr/bin/xml2rfc
 XSLTPROC = no
 abs_builddir = /home/dormando/d/p/danga/git/memcached/doc
diff --git a/doc/memcached.1 b/doc/memcached.1
index caa53b7..04aca5f 100644
--- a/doc/memcached.1
+++ b/doc/memcached.1
@@ -62,10 +62,10 @@ caches, so consult the README and memcached homepage for configuration
 suggestions.
 .TP
 .B \-p, --port=<num>
-Listen on TCP port <num>, the default is port 11211.
+Listen on TCP port <num>, the default is port 11211. 0 means off.
 .TP
 .B \-U, --udp-port=<num>
-Listen on UDP port <num>, the default is port 11211, 0 is off.
+Listen on UDP port <num>, the default is port 0, which is off.
 .TP
 .B \-M, --disable-evictions
 Disable automatic removal of items from the cache when out of memory.
diff --git a/doc/protocol.txt b/doc/protocol.txt
index 9c8e8bc..0984594 100644
--- a/doc/protocol.txt
+++ b/doc/protocol.txt
@@ -849,6 +849,8 @@ other stats command.
 |                   | bool     | If yes, stores numbers from VALUE response   |
 |                   |          | inside an item, using up to 24 bytes.        |
 |                   |          | Small slowdown for ASCII get, faster sets.   |
+| drop_privileges   | bool     | If yes, and available, drop unused syscalls  |
+|                   |          | (see seccomp on Linux, pledge on OpenBSD)    |
 |-------------------+----------+----------------------------------------------|
 
 
diff --git a/extstore.c b/extstore.c
index 02558c0..726435c 100644
--- a/extstore.c
+++ b/extstore.c
@@ -62,6 +62,7 @@ typedef struct _store_page {
     unsigned int allocated;
     unsigned int written; /* item offsets can be past written if wbuf not flushed */
     unsigned int bucket; /* which bucket the page is linked into */
+    unsigned int free_bucket; /* which bucket this page returns to when freed */
     int fd;
     unsigned short id;
     bool active; /* actively being written to */
@@ -95,6 +96,7 @@ struct store_engine {
     store_maint_thread *maint_thread;
     store_page *page_freelist;
     store_page **page_buckets; /* stack of pages currently allocated to each bucket */
+    store_page **free_page_buckets; /* stack of use-case isolated free pages */
     size_t page_size;
     unsigned int version; /* global version counter */
     unsigned int last_io_thread; /* round robin the IO threads */
@@ -102,6 +104,7 @@ struct store_engine {
     unsigned int page_count;
     unsigned int page_free; /* unallocated pages */
     unsigned int page_bucketcount; /* count of potential page buckets */
+    unsigned int free_page_bucketcount; /* count of free page buckets */
     unsigned int io_depth; /* FIXME: Might cache into thr struct */
     pthread_mutex_t stats_mutex;
     struct extstore_stats stats;
@@ -192,11 +195,11 @@ const char *extstore_err(enum extstore_res res) {
     return rv;
 }
 
-void *extstore_init(char *fn, struct extstore_conf *cf,
+// TODO: #define's for DEFAULT_BUCKET, FREE_VERSION, etc
+void *extstore_init(struct extstore_conf_file *fh, struct extstore_conf *cf,
         enum extstore_res *res) {
     int i;
-    int fd;
-    uint64_t offset = 0;
+    struct extstore_conf_file *f = NULL;
     pthread_t thread;
 
     if (cf->page_size % cf->wbuf_size != 0) {
@@ -227,43 +230,72 @@ void *extstore_init(char *fn, struct extstore_conf *cf,
     }
 
     e->page_size = cf->page_size;
-    fd = open(fn, O_RDWR | O_CREAT | O_TRUNC, 0644);
-    if (fd < 0) {
-        *res = EXTSTORE_INIT_OPEN_FAIL;
+    for (f = fh; f != NULL; f = f->next) {
+        f->fd = open(f->file, O_RDWR | O_CREAT | O_TRUNC, 0644);
+        if (f->fd < 0) {
+            *res = EXTSTORE_INIT_OPEN_FAIL;
 #ifdef EXTSTORE_DEBUG
-        perror("open");
+            perror("open");
 #endif
-        free(e);
-        return NULL;
+            free(e);
+            return NULL;
+        }
+        e->page_count += f->page_count;
+        f->offset = 0;
     }
 
-    e->pages = calloc(cf->page_count, sizeof(store_page));
+    e->pages = calloc(e->page_count, sizeof(store_page));
     if (e->pages == NULL) {
         *res = EXTSTORE_INIT_OOM;
-        close(fd);
+        // FIXME: loop-close. make error label
         free(e);
         return NULL;
     }
 
-    for (i = 0; i < cf->page_count; i++) {
+    // interleave the pages between devices
+    f = NULL; // start at the first device.
+    for (i = 0; i < e->page_count; i++) {
+        // find next device with available pages
+        while (1) {
+            // restart the loop
+            if (f == NULL || f->next == NULL) {
+                f = fh;
+            } else {
+                f = f->next;
+            }
+            if (f->page_count) {
+                f->page_count--;
+                break;
+            }
+        }
         pthread_mutex_init(&e->pages[i].mutex, NULL);
         e->pages[i].id = i;
-        e->pages[i].fd = fd;
-        e->pages[i].offset = offset;
+        e->pages[i].fd = f->fd;
+        e->pages[i].free_bucket = f->free_bucket;
+        e->pages[i].offset = f->offset;
         e->pages[i].free = true;
-        offset += e->page_size;
+        f->offset += e->page_size;
     }
 
-    for (i = cf->page_count-1; i > 0; i--) {
-        e->pages[i].next = e->page_freelist;
-        e->page_freelist = &e->pages[i];
+    // free page buckets allows the app to organize devices by use case
+    e->free_page_buckets = calloc(cf->page_buckets, sizeof(store_page *));
+    e->page_bucketcount = cf->page_buckets;
+
+    for (i = e->page_count-1; i > 0; i--) {
         e->page_free++;
+        if (e->pages[i].free_bucket == 0) {
+            e->pages[i].next = e->page_freelist;
+            e->page_freelist = &e->pages[i];
+        } else {
+            int fb = e->pages[i].free_bucket;
+            e->pages[i].next = e->free_page_buckets[fb];
+            e->free_page_buckets[fb] = &e->pages[i];
+        }
     }
 
     // 0 is magic "page is freed" version
     e->version = 1;
 
-    e->page_count = cf->page_count;
     // scratch data for stats. TODO: malloc failure handle
     e->stats.page_data =
         calloc(e->page_count, sizeof(struct extstore_page_data));
@@ -305,8 +337,12 @@ void *extstore_init(char *fn, struct extstore_conf *cf,
     e->maint_thread = calloc(1, sizeof(store_maint_thread));
     e->maint_thread->e = e;
     // FIXME: error handling
+    pthread_mutex_init(&e->maint_thread->mutex, NULL);
+    pthread_cond_init(&e->maint_thread->cond, NULL);
     pthread_create(&thread, NULL, extstore_maint_thread, e->maint_thread);
 
+    extstore_run_maint(e);
+
     return (void *)e;
 }
 
@@ -316,13 +352,25 @@ void extstore_run_maint(void *ptr) {
 }
 
 // call with *e locked
-static store_page *_allocate_page(store_engine *e, unsigned int bucket) {
+static store_page *_allocate_page(store_engine *e, unsigned int bucket,
+        unsigned int free_bucket) {
     assert(!e->page_buckets[bucket] || e->page_buckets[bucket]->allocated == e->page_size);
-    store_page *tmp = e->page_freelist;
-    E_DEBUG("EXTSTORE: allocating new page\n");
-    if (e->page_free > 0) {
-        assert(e->page_freelist != NULL);
+    store_page *tmp = NULL;
+    // if a specific free bucket was requested, check there first
+    if (free_bucket != 0 && e->free_page_buckets[free_bucket] != NULL) {
+        assert(e->page_free > 0);
+        tmp = e->free_page_buckets[free_bucket];
+        e->free_page_buckets[free_bucket] = tmp->next;
+    }
+    // failing that, try the global list.
+    if (tmp == NULL && e->page_freelist != NULL) {
+        tmp = e->page_freelist;
         e->page_freelist = tmp->next;
+    }
+    E_DEBUG("EXTSTORE: allocating new page\n");
+    // page_freelist can be empty if the only free pages are specialized and
+    // we didn't just request one.
+    if (e->page_free > 0 && tmp != NULL) {
         tmp->next = e->page_buckets[bucket];
         e->page_buckets[bucket] = tmp;
         tmp->active = true;
@@ -432,7 +480,8 @@ static void _submit_wbuf(store_engine *e, store_page *p) {
  * new page. best if used from a background thread that can harmlessly retry.
  */
 
-int extstore_write_request(void *ptr, unsigned int bucket, obj_io *io) {
+int extstore_write_request(void *ptr, unsigned int bucket,
+        unsigned int free_bucket, obj_io *io) {
     store_engine *e = (store_engine *)ptr;
     store_page *p;
     int ret = -1;
@@ -442,7 +491,7 @@ int extstore_write_request(void *ptr, unsigned int bucket, obj_io *io) {
     pthread_mutex_lock(&e->mutex);
     p = e->page_buckets[bucket];
     if (!p) {
-        p = _allocate_page(e, bucket);
+        p = _allocate_page(e, bucket, free_bucket);
     }
     pthread_mutex_unlock(&e->mutex);
     if (!p)
@@ -456,7 +505,7 @@ int extstore_write_request(void *ptr, unsigned int bucket, obj_io *io) {
             ((!p->wbuf || p->wbuf->full) && p->allocated >= e->page_size)) {
         pthread_mutex_unlock(&p->mutex);
         pthread_mutex_lock(&e->mutex);
-        _allocate_page(e, bucket);
+        _allocate_page(e, bucket, free_bucket);
         pthread_mutex_unlock(&e->mutex);
         return ret;
     }
@@ -510,7 +559,7 @@ void extstore_write(void *ptr, obj_io *io) {
 /* engine submit function; takes engine, item_io stack.
  * lock io_thread context and add stack?
  * signal io thread to wake.
- * return sucess.
+ * return success.
  */
 int extstore_submit(void *ptr, obj_io *io) {
     store_engine *e = (store_engine *)ptr;
@@ -603,7 +652,7 @@ void extstore_close_page(void *ptr, unsigned int page_id, uint64_t page_version)
 
 /* Finds an attached wbuf that can satisfy the read.
  * Since wbufs can potentially be flushed to disk out of order, they are only
- * removed as the head of the list successfuly flushes to disk.
+ * removed as the head of the list successfully flushes to disk.
  */
 // call with *p locked
 // FIXME: protect from reading past wbuf
@@ -762,8 +811,14 @@ static void _free_page(store_engine *e, store_page *p) {
     p->closed = false;
     p->free = true;
     // add to page stack
-    p->next = e->page_freelist;
-    e->page_freelist = p;
+    // TODO: free_page_buckets first class and remove redundancy?
+    if (p->free_bucket != 0) {
+        p->next = e->free_page_buckets[p->free_bucket];
+        e->free_page_buckets[p->free_bucket] = p;
+    } else {
+        p->next = e->page_freelist;
+        e->page_freelist = p;
+    }
     e->page_free++;
     pthread_mutex_unlock(&e->mutex);
 }
@@ -795,7 +850,9 @@ static void *extstore_maint_thread(void *arg) {
 
         pthread_cond_wait(&me->cond, &me->mutex);
         pthread_mutex_lock(&e->mutex);
-        if (e->page_free == 0) {
+        // default freelist requires at least one page free.
+        // specialized freelists fall back to default once full.
+        if (e->page_free == 0 || e->page_freelist == NULL) {
             do_evict = true;
         }
         pthread_mutex_unlock(&e->mutex);
@@ -804,6 +861,7 @@ static void *extstore_maint_thread(void *arg) {
         for (i = 0; i < e->page_count; i++) {
             store_page *p = &e->pages[i];
             pthread_mutex_lock(&p->mutex);
+            pd[p->id].free_bucket = p->free_bucket;
             if (p->active || p->free) {
                 pthread_mutex_unlock(&p->mutex);
                 continue;
@@ -812,7 +870,13 @@ static void *extstore_maint_thread(void *arg) {
                 pd[p->id].version = p->version;
                 pd[p->id].bytes_used = p->bytes_used;
                 pd[p->id].bucket = p->bucket;
-                if (p->version < low_version) {
+                // low_version/low_page are only used in the eviction
+                // scenario. when we evict, it's only to fill the default page
+                // bucket again.
+                // TODO: experiment with allowing evicting up to a single page
+                // for any specific free bucket. this is *probably* required
+                // since it could cause a load bias on default-only devices?
+                if (p->free_bucket == 0 && p->version < low_version) {
                     low_version = p->version;
                     low_page = i;
                 }
diff --git a/extstore.h b/extstore.h
index a466562..6814415 100644
--- a/extstore.h
+++ b/extstore.h
@@ -8,6 +8,7 @@ struct extstore_page_data {
     uint64_t version;
     uint64_t bytes_used;
     unsigned int bucket;
+    unsigned int free_bucket;
 };
 
 /* Pages can have objects deleted from them at any time. This creates holes
@@ -43,12 +44,23 @@ struct extstore_conf {
     unsigned int page_size; // ideally 64-256M in size
     unsigned int page_count;
     unsigned int page_buckets; // number of different writeable pages
+    unsigned int free_page_buckets; // buckets of dedicated pages (see code)
     unsigned int wbuf_size; // must divide cleanly into page_size
     unsigned int wbuf_count; // this might get locked to "2 per active page"
     unsigned int io_threadcount;
     unsigned int io_depth; // with normal I/O, hits locks less. req'd for AIO
 };
 
+struct extstore_conf_file {
+    unsigned int page_count;
+    char *file;
+    int fd; // internal usage
+    uint64_t offset; // internal usage
+    unsigned int bucket; // free page bucket
+    unsigned int free_bucket; // specialized free bucket
+    struct extstore_conf_file *next;
+};
+
 enum obj_io_mode {
     OBJ_IO_READ = 0,
     OBJ_IO_WRITE,
@@ -87,8 +99,8 @@ enum extstore_res {
 };
 
 const char *extstore_err(enum extstore_res res);
-void *extstore_init(char *fn, struct extstore_conf *cf, enum extstore_res *res);
-int extstore_write_request(void *ptr, unsigned int bucket, obj_io *io);
+void *extstore_init(struct extstore_conf_file *fh, struct extstore_conf *cf, enum extstore_res *res);
+int extstore_write_request(void *ptr, unsigned int bucket, unsigned int free_bucket, obj_io *io);
 void extstore_write(void *ptr, obj_io *io);
 int extstore_submit(void *ptr, obj_io *io);
 /* count are the number of objects being removed, bytes are the original
diff --git a/items.c b/items.c
index 0aefaf0..d4ce5a1 100644
--- a/items.c
+++ b/items.c
@@ -285,6 +285,13 @@ item *do_item_alloc(char *key, const size_t nkey, const unsigned int flags,
         if (settings.use_cas) {
             htotal += sizeof(uint64_t);
         }
+#ifdef NEED_ALIGN
+        // header chunk needs to be padded on some systems
+        int remain = htotal % 8;
+        if (remain != 0) {
+            htotal += 8 - remain;
+        }
+#endif
         hdr_id = slabs_clsid(htotal);
         it = do_item_alloc_pull(htotal, hdr_id);
         /* setting ITEM_CHUNKED is fine here because we aren't LINKED yet. */
@@ -336,7 +343,7 @@ item *do_item_alloc(char *key, const size_t nkey, const unsigned int flags,
 
     /* Initialize internal chunk. */
     if (it->it_flags & ITEM_CHUNKED) {
-        item_chunk *chunk = (item_chunk *) ITEM_data(it);
+        item_chunk *chunk = (item_chunk *) ITEM_schunk(it);
 
         chunk->next = 0;
         chunk->prev = 0;
@@ -1538,7 +1545,6 @@ static void *lru_maintainer_thread(void *arg) {
     void *storage = arg;
     if (storage != NULL)
         sam = &slab_automove_extstore;
-    int x;
 #endif
     int i;
     useconds_t to_sleep = MIN_LRU_MAINTAINER_SLEEP;
@@ -1592,20 +1598,6 @@ static void *lru_maintainer_thread(void *arg) {
             }
 
             int did_moves = lru_maintainer_juggle(i);
-#ifdef EXTSTORE
-            // Deeper loop to speed up pushing to storage.
-            if (storage) {
-                for (x = 0; x < 500; x++) {
-                    int found;
-                    found = lru_maintainer_store(storage, i);
-                    if (found) {
-                        did_moves += found;
-                    } else {
-                        break;
-                    }
-                }
-            }
-#endif
             if (did_moves == 0) {
                 if (backoff_juggles[i] != 0) {
                     backoff_juggles[i] += backoff_juggles[i] / 8;
diff --git a/linux_priv.c b/linux_priv.c
index 04155dd..cc9aef3 100644
--- a/linux_priv.c
+++ b/linux_priv.c
@@ -2,11 +2,11 @@
 #include <seccomp.h>
 #include <errno.h>
 #include <stdlib.h>
+#include <sys/ioctl.h>
 #include "memcached.h"
 
-// In the future when the system is more tested this could be switched
-// to SCMP_ACT_KILL instead.
-#define DENY_ACTION SCMP_ACT_ERRNO(EACCES)
+// If anything crosses the policy, kill the process.
+#define DENY_ACTION SCMP_ACT_KILL
 
 void drop_privileges(void) {
     scmp_filter_ctx ctx = seccomp_init(DENY_ACTION);
@@ -16,24 +16,41 @@ void drop_privileges(void) {
 
     int rc = 0;
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(sigreturn), 0);
+    rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(rt_sigprocmask), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(futex), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(epoll_wait), 0);
+    rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(epoll_pwait), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(accept4), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(accept), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 0);
+    rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(writev), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(fstat), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(mmap), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(munmap), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(shmctl), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit_group), 0);
+    rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(brk), 0);
+    rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(ioctl), 1, SCMP_A1(SCMP_CMP_EQ, TIOCGWINSZ));
+    rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(ioctl), 1, SCMP_A1(SCMP_CMP_EQ, TCGETS));
+
+#if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
+    rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(clock_gettime), 0);
+#endif
 
 #ifdef MEMCACHED_DEBUG
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(open), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(fcntl), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(read), 0);
+    rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(readv), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(lseek), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(close), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(getpid), 0);
+
+    if (settings.relaxed_privileges) {
+        rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(openat), 0);
+        rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(mkdir), 0);
+        rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(access), 0);
+    }
 #endif
 
     if (rc != 0) {
@@ -45,8 +62,13 @@ void drop_privileges(void) {
         goto fail;
     }
 
+    seccomp_release(ctx);
+    return;
+
 fail:
     seccomp_release(ctx);
+    fprintf(stderr, "Failed to set a seccomp profile on the main thread\n");
+    exit(EXIT_FAILURE);
 }
 
 void drop_worker_privileges(void) {
@@ -57,10 +79,14 @@ void drop_worker_privileges(void) {
 
     int rc = 0;
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(sigreturn), 0);
+    rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(rt_sigprocmask), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(futex), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(epoll_wait), 0);
+    rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(epoll_pwait), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(epoll_ctl), 0);
+    rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(poll), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(read), 0);
+    rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(readv), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(mprotect), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(getpeername), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(close), 0);
@@ -70,6 +96,8 @@ void drop_worker_privileges(void) {
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(mremap), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(munmap), 0);
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(recvfrom), 0);
+    rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(brk), 0);
+    rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(ioctl), 1, SCMP_A1(SCMP_CMP_EQ, TIOCGWINSZ));
 
     // for spawning the LRU crawler
     rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(clone), 0);
@@ -83,20 +111,29 @@ void drop_worker_privileges(void) {
 
     if (settings.shutdown_command) {
         rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(tgkill), 0);
+        rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(tkill), 0);
         rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit_group), 0);
         rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(fstat), 0);
-        rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(rt_sigprocmask), 0);
         rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(getpid), 0);
         rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(gettid), 0);
     }
 
     if (settings.relaxed_privileges) {
+        rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(openat), 0);
+        rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(mkdir), 0);
+        rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(access), 0);
         rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(open), 0);
         rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(fcntl), 0);
         rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(lseek), 0);
         rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 0);
+        rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(writev), 0);
     } else {
+        // stdout
         rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 1, SCMP_A0(SCMP_CMP_EQ, 1));
+        rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(writev), 1, SCMP_A0(SCMP_CMP_EQ, 1));
+        // stderr
+        rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 1, SCMP_A0(SCMP_CMP_EQ, 2));
+        rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(writev), 1, SCMP_A0(SCMP_CMP_EQ, 2));
     }
 
     if (rc != 0) {
@@ -108,6 +145,11 @@ void drop_worker_privileges(void) {
         goto fail;
     }
 
+    seccomp_release(ctx);
+    return;
+
 fail:
     seccomp_release(ctx);
+    fprintf(stderr, "Failed to set a seccomp profile on a worker thread\n");
+    exit(EXIT_FAILURE);
 }
diff --git a/logger.c b/logger.c
index 7af9917..1322d7d 100644
--- a/logger.c
+++ b/logger.c
@@ -363,7 +363,7 @@ static int logger_thread_read(logger *l, struct logger_stats *ls) {
         } else {
             logger_thread_write_entry(e, ls, scratch, scratch_len);
         }
-        pos += sizeof(logentry) + e->size;
+        pos += sizeof(logentry) + e->size + e->pad;
     }
     assert(pos <= size);
 
@@ -699,8 +699,9 @@ enum logger_ret_type logger_log(logger *l, const enum log_entry_type event, cons
         l->dropped++;
         return LOGGER_RET_NOSPACE;
     }
-    e->gid = logger_get_gid();
     e->event = d->subtype;
+    e->pad = 0;
+    e->gid = logger_get_gid();
     /* TODO: Could pass this down as an argument now that we're using
      * LOGGER_LOG() macro.
      */
@@ -751,11 +752,19 @@ enum logger_ret_type logger_log(logger *l, const enum log_entry_type event, cons
             rel_time_t sttl = va_arg(ap, rel_time_t);
             uint8_t sclsid = va_arg(ap, int);
             _logger_log_item_store(e, status, comm, skey, snkey, sttl, sclsid);
+            va_end(ap);
             break;
     }
 
+#ifdef NEED_ALIGN
+    /* Need to ensure *next* request is aligned. */
+    if (sizeof(logentry) + e->size % 8 != 0) {
+        e->pad = 8 - (sizeof(logentry) + e->size % 8);
+    }
+#endif
+
     /* Push pointer forward by the actual amount required */
-    if (bipbuf_push(buf, (sizeof(logentry) + e->size)) == 0) {
+    if (bipbuf_push(buf, (sizeof(logentry) + e->size + e->pad)) == 0) {
         fprintf(stderr, "LOGGER: Failed to bipbuf push a text entry\n");
         pthread_mutex_unlock(&l->mutex);
         return LOGGER_RET_ERR;
diff --git a/logger.h b/logger.h
index 3d4c44c..730c86f 100644
--- a/logger.h
+++ b/logger.h
@@ -100,6 +100,7 @@ struct logentry_item_store {
 
 typedef struct _logentry {
     enum log_entry_subtype event;
+    uint8_t pad;
     uint16_t eflags;
     uint64_t gid;
     struct timeval tv; /* not monotonic! */
diff --git a/memcached.c b/memcached.c
index 7178666..621b317 100644
--- a/memcached.c
+++ b/memcached.c
@@ -271,7 +271,7 @@ static void settings_init(void) {
     settings.crawls_persleep = 1000;
     settings.logger_watcher_buf_size = LOGGER_WATCHER_BUF_SIZE;
     settings.logger_buf_size = LOGGER_BUF_SIZE;
-    settings.drop_privileges = true;
+    settings.drop_privileges = false;
 #ifdef MEMCACHED_DEBUG
     settings.relaxed_privileges = false;
 #endif
@@ -612,6 +612,7 @@ conn *conn_new(const int sfd, enum conn_states init_state,
     c->iovused = 0;
     c->msgcurr = 0;
     c->msgused = 0;
+    c->sasl_started = false;
     c->authenticated = false;
     c->last_cmd_time = current_time; /* initialize for idle kicker */
 #ifdef EXTSTORE
@@ -648,8 +649,19 @@ static void recache_or_free(conn *c, io_wrap *wrap) {
     item *it;
     it = (item *)wrap->io.buf;
     bool do_free = true;
-    // If request was ultimately a miss, unlink the header.
-    if (wrap->miss) {
+    if (wrap->active) {
+        // If request never dispatched, free the read buffer but leave the
+        // item header alone.
+        do_free = false;
+        size_t ntotal = ITEM_ntotal(wrap->hdr_it);
+        slabs_free(it, ntotal, slabs_clsid(ntotal));
+        c->io_wrapleft--;
+        assert(c->io_wrapleft >= 0);
+        pthread_mutex_lock(&c->thread->stats.mutex);
+        c->thread->stats.get_aborted_extstore++;
+        pthread_mutex_unlock(&c->thread->stats.mutex);
+    } else if (wrap->miss) {
+        // If request was ultimately a miss, unlink the header.
         do_free = false;
         size_t ntotal = ITEM_ntotal(wrap->hdr_it);
         item_unlink(wrap->hdr_it);
@@ -1020,7 +1032,7 @@ static int add_iov(conn *c, const void *buf, int len) {
 
 static int add_chunked_item_iovs(conn *c, item *it, int len) {
     assert(it->it_flags & ITEM_CHUNKED);
-    item_chunk *ch = (item_chunk *) ITEM_data(it);
+    item_chunk *ch = (item_chunk *) ITEM_schunk(it);
     while (ch) {
         int todo = (len > ch->used) ? ch->used : len;
         if (add_iov(c, ch->data, todo) != 0) {
@@ -1640,13 +1652,8 @@ static void process_bin_get_or_touch(conn *c) {
         rsp->message.header.response.cas = htonll(ITEM_get_cas(it));
 
         // add the flags
-        if (settings.inline_ascii_response) {
-            rsp->message.body.flags = htonl(strtoul(ITEM_suffix(it), NULL, 10));
-        } else if (it->nsuffix > 0) {
-            rsp->message.body.flags = htonl(*((uint32_t *)ITEM_suffix(it)));
-        } else {
-            rsp->message.body.flags = 0;
-        }
+        FLAGS_CONV(settings.inline_ascii_response, it, rsp->message.body.flags);
+        rsp->message.body.flags = htonl(rsp->message.body.flags);
         add_iov(c, &rsp->message.body, sizeof(rsp->message.body));
 
         if (should_return_key) {
@@ -1663,10 +1670,14 @@ static void process_bin_get_or_touch(conn *c) {
                     iovcnt = 3;
                     iovst = c->iovused - 2;
                 }
-                // FIXME: this can return an error, but code flow doesn't
-                // allow bailing here.
-                if (_get_extstore(c, it, iovst, iovcnt) != 0)
+
+                if (_get_extstore(c, it, iovst, iovcnt) != 0) {
+                    pthread_mutex_lock(&c->thread->stats.mutex);
+                    c->thread->stats.get_oom_extstore++;
+                    pthread_mutex_unlock(&c->thread->stats.mutex);
+
                     failed = true;
+                }
             } else if ((it->it_flags & ITEM_CHUNKED) == 0) {
                 add_iov(c, ITEM_data(it), it->nbytes - 2);
             } else {
@@ -1686,10 +1697,11 @@ static void process_bin_get_or_touch(conn *c) {
             c->write_and_go = conn_new_cmd;
             /* Remember this command so we can garbage collect it later */
 #ifdef EXTSTORE
-            if ((it->it_flags & ITEM_HDR) == 0) {
-                c->item = it;
-            } else {
+            if ((it->it_flags & ITEM_HDR) != 0 && should_return_value) {
+                // Only have extstore clean if header and returning value.
                 c->item = NULL;
+            } else {
+                c->item = it;
             }
 #else
             c->item = it;
@@ -2105,8 +2117,16 @@ static void process_bin_complete_sasl_auth(conn *c) {
         result = sasl_server_start(c->sasl_conn, mech,
                                    challenge, vlen,
                                    &out, &outlen);
+        c->sasl_started = (result == SASL_OK || result == SASL_CONTINUE);
         break;
     case PROTOCOL_BINARY_CMD_SASL_STEP:
+        if (!c->sasl_started) {
+            if (settings.verbose) {
+                fprintf(stderr, "%d: SASL_STEP called but sasl_server_start "
+                        "not called for this connection!\n", c->sfd);
+            }
+            break;
+        }
         result = sasl_server_step(c->sasl_conn,
                                   challenge, vlen,
                                   &out, &outlen);
@@ -2465,7 +2485,15 @@ static void process_bin_update(conn *c) {
     }
 
     c->item = it;
+#ifdef NEED_ALIGN
+    if (it->it_flags & ITEM_CHUNKED) {
+        c->ritem = ITEM_schunk(it);
+    } else {
+        c->ritem = ITEM_data(it);
+    }
+#else
     c->ritem = ITEM_data(it);
+#endif
     c->rlbytes = vlen;
     conn_set_state(c, conn_nread);
     c->substate = bin_read_set_value;
@@ -2520,7 +2548,15 @@ static void process_bin_append_prepend(conn *c) {
     }
 
     c->item = it;
+#ifdef NEED_ALIGN
+    if (it->it_flags & ITEM_CHUNKED) {
+        c->ritem = ITEM_schunk(it);
+    } else {
+        c->ritem = ITEM_data(it);
+    }
+#else
     c->ritem = ITEM_data(it);
+#endif
     c->rlbytes = vlen;
     conn_set_state(c, conn_nread);
     c->substate = bin_read_set_value;
@@ -2681,7 +2717,7 @@ static void complete_nread(conn *c) {
 /* Destination must always be chunked */
 /* This should be part of item.c */
 static int _store_item_copy_chunks(item *d_it, item *s_it, const int len) {
-    item_chunk *dch = (item_chunk *) ITEM_data(d_it);
+    item_chunk *dch = (item_chunk *) ITEM_schunk(d_it);
     /* Advance dch until we find free space */
     while (dch->size == dch->used) {
         if (dch->next) {
@@ -2693,7 +2729,7 @@ static int _store_item_copy_chunks(item *d_it, item *s_it, const int len) {
 
     if (s_it->it_flags & ITEM_CHUNKED) {
         int remain = len;
-        item_chunk *sch = (item_chunk *) ITEM_data(s_it);
+        item_chunk *sch = (item_chunk *) ITEM_schunk(s_it);
         int copied = 0;
         /* Fills dch's to capacity, not straight copy sch in case data is
          * being added or removed (ie append/prepend)
@@ -2857,15 +2893,7 @@ enum store_item_type do_store_item(item *it, int comm, conn *c, const uint32_t h
             if (stored == NOT_STORED) {
                 /* we have it and old_it here - alloc memory to hold both */
                 /* flags was already lost - so recover them from ITEM_suffix(it) */
-
-                if (settings.inline_ascii_response) {
-                    flags = (uint32_t) strtoul(ITEM_suffix(old_it), (char **) NULL, 10);
-                } else if (old_it->nsuffix > 0) {
-                    flags = *((uint32_t *)ITEM_suffix(old_it));
-                } else {
-                    flags = 0;
-                }
-
+                FLAGS_CONV(settings.inline_ascii_response, old_it, flags);
                 new_it = do_item_alloc(key, it->nkey, flags, old_it->exptime, it->nbytes + old_it->nbytes - 2 /* CRLF */);
 
                 /* copy data from it and old_it to new_it */
@@ -3105,6 +3133,8 @@ static void server_stats(ADD_STAT add_stats, conn *c) {
 #ifdef EXTSTORE
     if (c->thread->storage) {
         APPEND_STAT("get_extstore", "%llu", (unsigned long long)thread_stats.get_extstore);
+        APPEND_STAT("get_aborted_extstore", "%llu", (unsigned long long)thread_stats.get_aborted_extstore);
+        APPEND_STAT("get_oom_extstore", "%llu", (unsigned long long)thread_stats.get_oom_extstore);
         APPEND_STAT("recache_from_extstore", "%llu", (unsigned long long)thread_stats.recache_from_extstore);
         APPEND_STAT("miss_from_extstore", "%llu", (unsigned long long)thread_stats.miss_from_extstore);
         APPEND_STAT("badcrc_from_extstore", "%llu", (unsigned long long)thread_stats.badcrc_from_extstore);
@@ -3242,6 +3272,9 @@ static void process_stat_settings(ADD_STAT add_stats, void *c) {
     APPEND_STAT("worker_logbuf_size", "%u", settings.logger_buf_size);
     APPEND_STAT("track_sizes", "%s", item_stats_sizes_status() ? "yes" : "no");
     APPEND_STAT("inline_ascii_response", "%s", settings.inline_ascii_response ? "yes" : "no");
+#ifdef HAVE_DROP_PRIVILEGES
+    APPEND_STAT("drop_privileges", "%s", settings.drop_privileges ? "yes" : "no");
+#endif
 #ifdef EXTSTORE
     APPEND_STAT("ext_item_size", "%u", settings.ext_item_size);
     APPEND_STAT("ext_item_age", "%u", settings.ext_item_age);
@@ -3384,6 +3417,8 @@ static void process_extstore_stats(ADD_STAT add_stats, conn *c) {
                 (unsigned long long) st.page_data[i].bytes_used);
         APPEND_NUM_STAT(i, "bucket", "%u",
                 st.page_data[i].bucket);
+        APPEND_NUM_STAT(i, "free_bucket", "%u",
+                st.page_data[i].free_bucket);
     }
 }
 #endif
@@ -3583,14 +3618,14 @@ static void _get_extstore_cb(void *e, obj_io *io, int ret) {
         // item is chunked, crc the iov's
         if (io->iov != NULL) {
             // first iov is the header, which we don't use beyond crc
-            crc2 = crc32c(0, (char *)io->iov[0].iov_base+32, io->iov[0].iov_len-32);
+            crc2 = crc32c(0, (char *)io->iov[0].iov_base+STORE_OFFSET, io->iov[0].iov_len-STORE_OFFSET);
             // make sure it's not sent. hack :(
             io->iov[0].iov_len = 0;
             for (x = 1; x < io->iovcnt; x++) {
                 crc2 = crc32c(crc2, (char *)io->iov[x].iov_base, io->iov[x].iov_len);
             }
         } else {
-            crc2 = crc32c(0, (char *)read_it+32, io->len-32);
+            crc2 = crc32c(0, (char *)read_it+STORE_OFFSET, io->len-STORE_OFFSET);
         }
 
         if (crc != crc2) {
@@ -3639,6 +3674,7 @@ static void _get_extstore_cb(void *e, obj_io *io, int ret) {
                 }
             }
         }
+        wrap->miss = false;
         // iov_len is already set
         // TODO: Should do that here instead and cuddle in the wrap object
     }
@@ -3657,23 +3693,20 @@ static void _get_extstore_cb(void *e, obj_io *io, int ret) {
 
 // FIXME: This completely breaks UDP support.
 static inline int _get_extstore(conn *c, item *it, int iovst, int iovcnt) {
+#ifdef NEED_ALIGN
+    item_hdr hdr;
+    memcpy(&hdr, ITEM_data(it), sizeof(hdr));
+#else
     item_hdr *hdr = (item_hdr *)ITEM_data(it);
+#endif
     size_t ntotal = ITEM_ntotal(it);
     unsigned int clsid = slabs_clsid(ntotal);
     item *new_it;
     bool chunked = false;
     if (ntotal > settings.slab_chunk_size_max) {
         // Pull a chunked item header.
-        // FIXME: make a func. used in several places.
         uint32_t flags;
-        if (settings.inline_ascii_response) {
-            flags = (uint32_t) strtoul(ITEM_suffix(it), (char **) NULL, 10);
-        } else if (it->nsuffix > 0) {
-            flags = *((uint32_t *)ITEM_suffix(it));
-        } else {
-            flags = 0;
-        }
-
+        FLAGS_CONV(settings.inline_ascii_response, it, flags);
         new_it = item_alloc(ITEM_key(it), it->nkey, flags, it->exptime, it->nbytes);
         assert(new_it == NULL || (new_it->it_flags & ITEM_CHUNKED));
         chunked = true;
@@ -3702,13 +3735,12 @@ static inline int _get_extstore(conn *c, item *it, int iovst, int iovcnt) {
     if (chunked) {
         unsigned int ciovcnt = 1;
         size_t remain = new_it->nbytes;
-        item_chunk *chunk = (item_chunk *) ITEM_data(new_it);
+        item_chunk *chunk = (item_chunk *) ITEM_schunk(new_it);
         io->io.iov = &c->iov[c->iovused];
         // fill the header so we can get the full data + crc back.
         add_iov(c, new_it, ITEM_ntotal(new_it) - new_it->nbytes);
         while (remain > 0) {
             chunk = do_item_alloc_chunk(chunk, remain);
-            // TODO: counter bump
             if (chunk == NULL) {
                 item_remove(new_it);
                 do_cache_free(c->thread->io_cache, io);
@@ -3745,9 +3777,15 @@ static inline int _get_extstore(conn *c, item *it, int iovst, int iovcnt) {
     io->io.data = (void *)io;
 
     // Now, fill in io->io based on what was in our header.
+#ifdef NEED_ALIGN
+    io->io.page_version = hdr.page_version;
+    io->io.page_id = hdr.page_id;
+    io->io.offset = hdr.offset;
+#else
     io->io.page_version = hdr->page_version;
     io->io.page_id = hdr->page_id;
     io->io.offset = hdr->offset;
+#endif
     io->io.len = ntotal;
     io->io.mode = OBJ_IO_READ;
     io->io.cb = _get_extstore_cb;
@@ -3763,8 +3801,6 @@ static inline int _get_extstore(conn *c, item *it, int iovst, int iovcnt) {
     return 0;
 }
 #endif
-// FIXME: the 'breaks' around memory malloc's should break all the way down,
-// fill ileft/suffixleft, then run conn_releaseitems()
 /* ntokens is overwritten here... shrug.. */
 static inline void process_get_command(conn *c, token_t *tokens, size_t ntokens, bool return_cas, bool should_touch) {
     char *key;
@@ -3776,6 +3812,7 @@ static inline void process_get_command(conn *c, token_t *tokens, size_t ntokens,
     char *suffix;
     int32_t exptime_int = 0;
     rel_time_t exptime = 0;
+    bool fail_length = false;
     assert(c != NULL);
 
     if (should_touch) {
@@ -3795,14 +3832,8 @@ static inline void process_get_command(conn *c, token_t *tokens, size_t ntokens,
             nkey = key_token->length;
 
             if (nkey > KEY_MAX_LENGTH) {
-                out_string(c, "CLIENT_ERROR bad command line format");
-                while (i-- > 0) {
-                    item_remove(*(c->ilist + i));
-                    if (return_cas || !settings.inline_ascii_response) {
-                        do_cache_free(c->thread->suffix_cache, *(c->suffixlist + i));
-                    }
-                }
-                return;
+                fail_length = true;
+                goto stop;
             }
 
             it = limited_get(key, nkey, c, exptime, should_touch);
@@ -3812,7 +3843,7 @@ static inline void process_get_command(conn *c, token_t *tokens, size_t ntokens,
             if (it) {
                 if (_ascii_get_expand_ilist(c, i) != 0) {
                     item_remove(it);
-                    break; // FIXME: Should bail down to error.
+                    goto stop;
                 }
 
                 /*
@@ -3831,7 +3862,7 @@ static inline void process_get_command(conn *c, token_t *tokens, size_t ntokens,
                   suffix = _ascii_get_suffix_buf(c, si);
                   if (suffix == NULL) {
                       item_remove(it);
-                      break;
+                      goto stop;
                   }
                   si++;
                   nbytes = it->nbytes;
@@ -3842,13 +3873,17 @@ static inline void process_get_command(conn *c, token_t *tokens, size_t ntokens,
                       add_iov(c, suffix, suffix_len) != 0)
                       {
                           item_remove(it);
-                          break;
+                          goto stop;
                       }
 #ifdef EXTSTORE
                   if (it->it_flags & ITEM_HDR) {
                       if (_get_extstore(c, it, c->iovused-3, 4) != 0) {
+                          pthread_mutex_lock(&c->thread->stats.mutex);
+                          c->thread->stats.get_oom_extstore++;
+                          pthread_mutex_unlock(&c->thread->stats.mutex);
+
                           item_remove(it);
-                          break;
+                          goto stop;
                       }
                   } else if ((it->it_flags & ITEM_CHUNKED) == 0) {
 #else
@@ -3857,7 +3892,7 @@ static inline void process_get_command(conn *c, token_t *tokens, size_t ntokens,
                       add_iov(c, ITEM_data(it), it->nbytes);
                   } else if (add_chunked_item_iovs(c, it, it->nbytes) != 0) {
                       item_remove(it);
-                      break;
+                      goto stop;
                   }
                 }
                 else
@@ -3868,19 +3903,19 @@ static inline void process_get_command(conn *c, token_t *tokens, size_t ntokens,
                       add_iov(c, ITEM_key(it), it->nkey) != 0)
                       {
                           item_remove(it);
-                          break;
+                          goto stop;
                       }
                   if ((it->it_flags & ITEM_CHUNKED) == 0)
                       {
                           if (add_iov(c, ITEM_suffix(it), it->nsuffix + it->nbytes) != 0)
                           {
                               item_remove(it);
-                              break;
+                              goto stop;
                           }
                       } else if (add_iov(c, ITEM_suffix(it), it->nsuffix) != 0 ||
                                  add_chunked_item_iovs(c, it, it->nbytes) != 0) {
                           item_remove(it);
-                          break;
+                          goto stop;
                       }
                 }
 
@@ -3940,6 +3975,7 @@ static inline void process_get_command(conn *c, token_t *tokens, size_t ntokens,
         }
 
     } while(key_token->value != NULL);
+stop:
 
     c->icurr = c->ilist;
     c->ileft = i;
@@ -3958,7 +3994,12 @@ static inline void process_get_command(conn *c, token_t *tokens, size_t ntokens,
     */
     if (key_token->value != NULL || add_iov(c, "END\r\n", 5) != 0
         || (IS_UDP(c->transport) && build_udp_headers(c) != 0)) {
-        out_of_memory(c, "SERVER_ERROR out of memory writing get response");
+        if (fail_length) {
+            out_string(c, "CLIENT_ERROR bad command line format");
+        } else {
+            out_of_memory(c, "SERVER_ERROR out of memory writing get response");
+        }
+        conn_release_items(c);
     }
     else {
         conn_set_state(c, conn_mwrite);
@@ -4055,7 +4096,15 @@ static void process_update_command(conn *c, token_t *tokens, const size_t ntoken
     ITEM_set_cas(it, req_cas_id);
 
     c->item = it;
+#ifdef NEED_ALIGN
+    if (it->it_flags & ITEM_CHUNKED) {
+        c->ritem = ITEM_schunk(it);
+    } else {
+        c->ritem = ITEM_data(it);
+    }
+#else
     c->ritem = ITEM_data(it);
+#endif
     c->rlbytes = it->nbytes;
     c->cmd = comm;
     conn_set_state(c, conn_nread);
@@ -4239,13 +4288,7 @@ enum delta_result_type do_add_delta(conn *c, const char *key, const size_t nkey,
     } else if (it->refcount > 1) {
         item *new_it;
         uint32_t flags;
-        if (settings.inline_ascii_response) {
-            flags = (uint32_t) strtoul(ITEM_suffix(it), (char **) NULL, 10);
-        } else if (it->nsuffix > 0) {
-            flags = *((uint32_t *)ITEM_suffix(it));
-        } else {
-            flags = 0;
-        }
+        FLAGS_CONV(settings.inline_ascii_response, it, flags);
         new_it = do_item_alloc(ITEM_key(it), it->nkey, flags, it->exptime, res + 2);
         if (new_it == 0) {
             do_item_remove(it);
@@ -5274,7 +5317,6 @@ static int read_into_chunked_item(conn *c) {
 
     while (c->rlbytes > 0) {
         item_chunk *ch = (item_chunk *)c->ritem;
-        assert(ch->used <= ch->size);
         if (ch->size == ch->used) {
             // FIXME: ch->next is currently always 0. remove this?
             if (ch->next) {
@@ -6156,7 +6198,7 @@ static void clock_handler(const int fd, const short which, void *arg) {
 static void usage(void) {
     printf(PACKAGE " " VERSION "\n");
     printf("-p, --port=<num>          TCP port to listen on (default: 11211)\n"
-           "-U, --udp-port=<num>      UDP port to listen on (default: 11211, 0 is off)\n"
+           "-U, --udp-port=<num>      UDP port to listen on (default: 0, off)\n"
            "-s, --unix-socket=<file>  UNIX socket to listen on (disables network support)\n"
            "-A, --enable-shutdown     enable ascii \"shutdown\" command\n"
            "-a, --unix-mask=<mask>    access mask for UNIX socket, in octal (default: 0700)\n"
@@ -6236,7 +6278,8 @@ static void usage(void) {
            "             currently: nothing\n"
            "   - no_modern:           uses defaults of previous major version (1.4.x)\n"
 #ifdef HAVE_DROP_PRIVILEGES
-           "   - no_drop_privileges: Disable drop_privileges in case it causes issues with\n"
+           "   - drop_privileges:     enable dropping extra syscall privileges\n"
+           "   - no_drop_privileges:  disable drop_privileges in case it causes issues with\n"
            "                          some customisation.\n"
 #ifdef MEMCACHED_DEBUG
            "   - relaxed_privileges: Running tests requires extra privileges.\n"
@@ -6244,6 +6287,7 @@ static void usage(void) {
 #endif
 #ifdef EXTSTORE
            "   - ext_path:            file to write to for external storage.\n"
+           "                          ie: ext_path=/mnt/d1/extstore:1G\n"
            "   - ext_page_size:       size in megabytes of storage pages.\n"
            "   - ext_wbuf_size:       size in megabytes of page write buffers.\n"
            "   - ext_threads:         number of IO threads to run.\n"
@@ -6255,6 +6299,7 @@ static void usage(void) {
            "   - ext_compact_under:   compact when fewer than this many free pages\n"
            "   - ext_drop_under:      drop COLD items when fewer than this many free pages\n"
            "   - ext_max_frag:        max page fragmentation to tolerage\n"
+           "   - slab_automove_freeratio: ratio of memory to hold free as buffer.\n"
            "                          (see doc/storage.txt for more info)\n"
 #endif
            );
@@ -6436,6 +6481,16 @@ static int enable_large_pages(void) {
     }
 
     return ret;
+#elif defined(__linux__) && defined(MADV_HUGEPAGE)
+    /* check if transparent hugepages is compiled into the kernel */
+    struct stat st;
+    int ret = stat("/sys/kernel/mm/transparent_hugepage/enabled", &st);
+    if (ret || !(st.st_mode & S_IFREG)) {
+        fprintf(stderr, "Transparent huge pages support not detected.\n");
+        fprintf(stderr, "Will use default page size.\n");
+        return -1;
+    }
+    return 0;
 #else
     return -1;
 #endif
@@ -6534,7 +6589,7 @@ int main (int argc, char **argv) {
     bool slab_chunk_size_changed = false;
 #ifdef EXTSTORE
     void *storage = NULL;
-    char *storage_file = NULL;
+    struct extstore_conf_file *storage_file = NULL;
     struct extstore_conf ext_cf;
 #endif
     char *subopts, *subopts_orig;
@@ -6575,12 +6630,12 @@ int main (int argc, char **argv) {
         NO_LRU_CRAWLER,
         NO_LRU_MAINTAINER,
         NO_DROP_PRIVILEGES,
+        DROP_PRIVILEGES,
 #ifdef MEMCACHED_DEBUG
         RELAXED_PRIVILEGES,
 #endif
 #ifdef EXTSTORE
         EXT_PAGE_SIZE,
-        EXT_PAGE_COUNT,
         EXT_WBUF_SIZE,
         EXT_THREADS,
         EXT_IO_DEPTH,
@@ -6632,12 +6687,12 @@ int main (int argc, char **argv) {
         [NO_LRU_CRAWLER] = "no_lru_crawler",
         [NO_LRU_MAINTAINER] = "no_lru_maintainer",
         [NO_DROP_PRIVILEGES] = "no_drop_privileges",
+        [DROP_PRIVILEGES] = "drop_privileges",
 #ifdef MEMCACHED_DEBUG
         [RELAXED_PRIVILEGES] = "relaxed_privileges",
 #endif
 #ifdef EXTSTORE
         [EXT_PAGE_SIZE] = "ext_page_size",
-        [EXT_PAGE_COUNT] = "ext_page_count",
         [EXT_WBUF_SIZE] = "ext_wbuf_size",
         [EXT_THREADS] = "ext_threads",
         [EXT_IO_DEPTH] = "ext_io_depth",
@@ -6677,7 +6732,6 @@ int main (int argc, char **argv) {
     settings.ext_drop_under = 0;
     settings.slab_automove_freeratio = 0.01;
     ext_cf.page_size = 1024 * 1024 * 64;
-    ext_cf.page_count = 64;
     ext_cf.wbuf_size = settings.ext_wbuf_size;
     ext_cf.io_threadcount = 1;
     ext_cf.io_depth = 1;
@@ -7203,16 +7257,6 @@ int main (int argc, char **argv) {
                 }
                 ext_cf.page_size *= 1024 * 1024; /* megabytes */
                 break;
-            case EXT_PAGE_COUNT:
-                if (subopts_value == NULL) {
-                    fprintf(stderr, "Missing ext_page_count argument\n");
-                    return 1;
-                }
-                if (!safe_strtoul(subopts_value, &ext_cf.page_count)) {
-                    fprintf(stderr, "could not parse argument to ext_page_count\n");
-                    return 1;
-                }
-                break;
             case EXT_WBUF_SIZE:
                 if (subopts_value == NULL) {
                     fprintf(stderr, "Missing ext_wbuf_size argument\n");
@@ -7329,7 +7373,20 @@ int main (int argc, char **argv) {
                 settings.ext_drop_unread = true;
                 break;
             case EXT_PATH:
-                storage_file = strdup(subopts_value);
+                if (subopts_value) {
+                    struct extstore_conf_file *tmp = storage_conf_parse(subopts_value, ext_cf.page_size);
+                    if (tmp == NULL) {
+                        fprintf(stderr, "failed to parse ext_path argument\n");
+                        return 1;
+                    }
+                    if (storage_file != NULL) {
+                        tmp->next = storage_file;
+                    }
+                    storage_file = tmp;
+                } else {
+                    fprintf(stderr, "missing argument to ext_path, ie: ext_path=/d/file:5G\n");
+                    return 1;
+                }
                 break;
 #endif
             case MODERN:
@@ -7351,6 +7408,9 @@ int main (int argc, char **argv) {
             case NO_DROP_PRIVILEGES:
                 settings.drop_privileges = false;
                 break;
+            case DROP_PRIVILEGES:
+                settings.drop_privileges = true;
+                break;
 #ifdef MEMCACHED_DEBUG
             case RELAXED_PRIVILEGES:
                 settings.relaxed_privileges = true;
@@ -7536,6 +7596,10 @@ int main (int argc, char **argv) {
             fprintf(stderr, "can't find the user %s to switch to\n", username);
             exit(EX_NOUSER);
         }
+        if (setgroups(0, NULL) < 0) {
+            fprintf(stderr, "failed to drop supplementary groups\n");
+            exit(EX_OSERR);
+        }
         if (setgid(pw->pw_gid) < 0 || setuid(pw->pw_uid) < 0) {
             fprintf(stderr, "failed to assume identity of user %s\n", username);
             exit(EX_OSERR);
@@ -7596,9 +7660,9 @@ int main (int argc, char **argv) {
     if (storage_file) {
         enum extstore_res eres;
         if (settings.ext_compact_under == 0) {
-            settings.ext_compact_under = ext_cf.page_count / 4;
+            settings.ext_compact_under = storage_file->page_count / 4;
             /* Only rescues non-COLD items if below this threshold */
-            settings.ext_drop_under = ext_cf.page_count / 4;
+            settings.ext_drop_under = storage_file->page_count / 4;
         }
         crc32c_init();
         /* Init free chunks to zero. */
@@ -7649,6 +7713,10 @@ int main (int argc, char **argv) {
         fprintf(stderr, "Failed to start storage compaction thread\n");
         exit(EXIT_FAILURE);
     }
+    if (storage && start_storage_write_thread(storage) != 0) {
+        fprintf(stderr, "Failed to start storage writer thread\n");
+        exit(EXIT_FAILURE);
+    }
 
     if (start_lru_maintainer && start_lru_maintainer_thread(storage) != 0) {
 #else
diff --git a/memcached.h b/memcached.h
index 22893f5..a8dd59d 100644
--- a/memcached.h
+++ b/memcached.h
@@ -18,6 +18,7 @@
 #include <pthread.h>
 #include <unistd.h>
 #include <assert.h>
+#include <grp.h>
 
 #include "itoa_ljust.h"
 #include "protocol_binary.h"
@@ -140,6 +141,17 @@
 #define APPEND_NUM_STAT(num, name, fmt, val) \
     APPEND_NUM_FMT_STAT("%d:%s", num, name, fmt, val)
 
+/** Item client flag conversion */
+#define FLAGS_CONV(iar, it, flag) { \
+    if ((iar)) { \
+        flag = (uint32_t) strtoul(ITEM_suffix((it)), (char **) NULL, 10); \
+    } else if ((it)->nsuffix > 0) { \
+        flag = *((uint32_t *)ITEM_suffix((it))); \
+    } else { \
+        flag = 0; \
+    } \
+}
+
 /**
  * Callback for any function producing stats.
  *
@@ -274,6 +286,8 @@ struct slab_stats {
 #ifdef EXTSTORE
 #define EXTSTORE_THREAD_STATS_FIELDS \
     X(get_extstore) \
+    X(get_aborted_extstore) \
+    X(get_oom_extstore) \
     X(recache_from_extstore) \
     X(miss_from_extstore) \
     X(badcrc_from_extstore)
@@ -510,6 +524,23 @@ typedef struct _strchunk {
     uint8_t          slabs_clsid; /* Same as above. */
     char data[];
 } item_chunk;
+
+#ifdef NEED_ALIGN
+static inline char *ITEM_schunk(item *it) {
+    int offset = it->nkey + 1 + it->nsuffix
+        + ((it->it_flags & ITEM_CAS) ? sizeof(uint64_t) : 0);
+    int remain = offset % 8;
+    if (remain != 0) {
+        offset += 8 - remain;
+    }
+    return ((char *) &(it->data)) + offset;
+}
+#else
+#define ITEM_schunk(item) ((char*) &((item)->data) + (item)->nkey + 1 \
+         + (item)->nsuffix \
+         + (((item)->it_flags & ITEM_CAS) ? sizeof(uint64_t) : 0))
+#endif
+
 #ifdef EXTSTORE
 typedef struct {
     unsigned int page_version; /* from IO header */
@@ -545,7 +576,7 @@ typedef struct _io_wrap {
     unsigned int iovec_data;  /* specific index of data iovec */
     bool miss;                /* signal a miss to unlink hdr_it */
     bool badcrc;              /* signal a crc failure */
-    bool active; // FIXME: canary for test. remove
+    bool active;              /* tells if IO was dispatched or not */
 } io_wrap;
 #endif
 /**
@@ -554,6 +585,7 @@ typedef struct _io_wrap {
 struct conn {
     int    sfd;
     sasl_conn_t *sasl_conn;
+    bool sasl_started;
     bool authenticated;
     enum conn_states  state;
     enum bin_substates substate;
@@ -713,7 +745,7 @@ void sidethread_conn_close(conn *c);
 
 /* Lock wrappers for cache functions that are called from main loop. */
 enum delta_result_type add_delta(conn *c, const char *key,
-                                 const size_t nkey, const int incr,
+                                 const size_t nkey, bool incr,
                                  const int64_t delta, char *buf,
                                  uint64_t *cas);
 void accept_new_conns(const bool do_accept);
diff --git a/memcached.spec b/memcached.spec
index 697c38f..295b7d9 100644
--- a/memcached.spec
+++ b/memcached.spec
@@ -17,7 +17,7 @@ BuildRequires: systemd-units
 %endif
 
 Name:           memcached
-Version:        1.5.6
+Version:        1.5.10
 Release:        1%{?dist}
 Summary:        High Performance, Distributed Memory Object Cache
 
@@ -79,9 +79,9 @@ install -Dp -m0755 scripts/memcached.service %{buildroot}%{_unitdir}/%{name}.ser
 install -Dp -m0755 scripts/memcached@.service %{buildroot}%{_unitdir}/%{name}@.service
 
 if [ %{safer_systemd} -gt 0 ]; then
-    sed -e -i 's/^##safer##//g' %{buildroot}%{_unitdir}/%{name}.service %{buildroot}%{_unitdir}/%{name}@.service
+    sed -e 's/^##safer##//g' -i %{buildroot}%{_unitdir}/%{name}.service %{buildroot}%{_unitdir}/%{name}@.service
 else
-    sed -e -i 's/^##safer##/#/g' %{buildroot}%{_unitdir}/%{name}.service %{buildroot}%{_unitdir}/%{name}@.service
+    sed -e 's/^##safer##/#/g' -i %{buildroot}%{_unitdir}/%{name}.service %{buildroot}%{_unitdir}/%{name}@.service
 fi
 %else
 install -Dp -m0755 scripts/memcached.sysv %{buildroot}%{_initrddir}/%{name}
@@ -187,7 +187,7 @@ exit 0
 - above suggestions from Bernard Johnson
 
 * Mon May  7 2007 Paul Lindner <[e-mail]> - 1.2.2-2
-- Tidyness improvements suggested by Ruben Kerkhof in bugzilla #238994
+- Tidiness improvements suggested by Ruben Kerkhof in bugzilla #238994
 
 * Fri May  4 2007 Paul Lindner <[e-mail]> - 1.2.2-1
 - Initial spec file created via rpmdev-newspec
diff --git a/sasl_defs.c b/sasl_defs.c
index 93a7b8b..c60d1bf 100644
--- a/sasl_defs.c
+++ b/sasl_defs.c
@@ -7,7 +7,7 @@
 
 char my_sasl_hostname[1025];
 
-#ifdef HAVE_SASL_CB_GETCONF
+#if defined(HAVE_SASL_CB_GETCONF) || defined(HAVE_SASL_CB_GETCONFPATH)
 /* The locations we may search for a SASL config file if the user didn't
  * specify one in the environment variable SASL_CONF_PATH
  */
@@ -82,7 +82,7 @@ static int sasl_server_userdb_checkpass(sasl_conn_t *conn,
 }
 #endif
 
-#ifdef HAVE_SASL_CB_GETCONF
+#if defined(HAVE_SASL_CB_GETCONF) || defined(HAVE_SASL_CB_GETCONFPATH)
 static int sasl_getconf(void *context, const char **path)
 {
     *path = getenv("SASL_CONF_PATH");
@@ -152,6 +152,10 @@ static sasl_callback_t sasl_callbacks[] = {
 
 #ifdef HAVE_SASL_CB_GETCONF
    { SASL_CB_GETCONF, sasl_getconf, NULL },
+#else
+#ifdef HAVE_SASL_CB_GETCONFPATH
+   { SASL_CB_GETCONFPATH, (sasl_callback_ft)sasl_getconf, NULL },
+#endif
 #endif
 
    { SASL_CB_LIST_END, NULL, NULL }
diff --git a/scripts/memcached-automove b/scripts/memcached-automove
index f881129..4a3d3dd 100755
--- a/scripts/memcached-automove
+++ b/scripts/memcached-automove
@@ -54,7 +54,7 @@ def determine_move(history, diffs, totals):
     - use age as average over window. smooths over items falling out of WARM.
       also gives a little weight: if still evicting, a few more pages than
       necessary may be moved, pulling the classes closer together. Hopefully
-      avoidnig ping-ponging.
+      avoiding ping-ponging.
     """
     # rotate windows
     history['w'].append({})
diff --git a/scripts/memcached-automove-extstore b/scripts/memcached-automove-extstore
index db66d8c..2bb0e35 100755
--- a/scripts/memcached-automove-extstore
+++ b/scripts/memcached-automove-extstore
@@ -64,7 +64,7 @@ def determine_move(history, stats, diffs, memfree):
       - if global pool is below minimum remove pages from oldest large class.
       - if global pool is above maximum, move pages to youngest large class.
     - extstore manages a desired number of free chunks in each slab class.
-    - autmover adjusts above limits once per minute based on current sizes.
+    - automover adjusts above limits once per minute based on current sizes.
     - if youngest is below the age ratio limit of oldest, move a page to it.
     """
     # rotate windows
@@ -85,7 +85,6 @@ def determine_move(history, stats, diffs, memfree):
         print("global pool: [{}]".format(stats['slab_global_page_pool']))
 
     pool_low = window_key_check(history, 'slab_pool_low')
-    pool_high = window_key_check(history, 'slab_pool_high')
     for sid, slab in diffs.items():
         small_slab = False
         free_enough = False
diff --git a/scripts/memcached-tool b/scripts/memcached-tool
index 79f3770..cab36a5 100755
--- a/scripts/memcached-tool
+++ b/scripts/memcached-tool
@@ -20,6 +20,7 @@ use IO::Socket::INET;
 my $addr = shift;
 my $mode = shift || "display";
 my ($from, $to);
+my $limit;
 
 if ($mode eq "display") {
     undef $mode if @ARGV;
@@ -30,7 +31,11 @@ if ($mode eq "display") {
     undef $mode if $to   < 6 || $to   > 17;
     print STDERR "ERROR: parameters out of range\n\n" unless $mode;
 } elsif ($mode eq 'dump') {
-    ;
+    if (@ARGV) {
+        $limit = shift;
+        undef $mode if $limit < 1;
+        print STDERR "ERROR: invalid limit (should be a positive number)\n\n" unless $mode;
+    }
 } elsif ($mode eq 'stats') {
     ;
 } elsif ($mode eq 'settings') {
@@ -45,12 +50,12 @@ undef $mode if @ARGV;
 
 die
     "Usage: memcached-tool <host[:port] | /path/to/socket> [mode]\n
-       memcached-tool 10.0.0.5:11211 display    # shows slabs
-       memcached-tool 10.0.0.5:11211            # same.  (default is display)
-       memcached-tool 10.0.0.5:11211 stats      # shows general stats
-       memcached-tool 10.0.0.5:11211 settings   # shows settings stats
-       memcached-tool 10.0.0.5:11211 sizes      # shows sizes stats
-       memcached-tool 10.0.0.5:11211 dump       # dumps keys and values
+       memcached-tool 10.0.0.5:11211 display        # shows slabs
+       memcached-tool 10.0.0.5:11211                # same.  (default is display)
+       memcached-tool 10.0.0.5:11211 stats          # shows general stats
+       memcached-tool 10.0.0.5:11211 settings       # shows settings stats
+       memcached-tool 10.0.0.5:11211 sizes          # shows sizes stats
+       memcached-tool 10.0.0.5:11211 dump [limit]   # dumps keys and values
 
 WARNING! sizes is a development command.
 As of 1.4 it is still the only command which will lock your memcached instance for some time.
@@ -60,65 +65,74 @@ or at least speed it up.
 " unless $addr && $mode;
 
 
-my $sock;
-if ($addr =~ m:/:) {
-    $sock = IO::Socket::UNIX->new(
-        Peer => $addr,
-    );
-}
-else {
-    $addr .= ':11211' unless $addr =~ /:\d+$/;
+sub server_connect {
+    my $sock;
+    if ($addr =~ m:/:) {
+        $sock = IO::Socket::UNIX->new(
+            Peer => $addr,
+        );
+    }
+    else {
+        $addr .= ':11211' unless $addr =~ /:\d+$/;
 
-    $sock = IO::Socket::INET->new(
-        PeerAddr => $addr,
-        Proto    => 'tcp',
-    );
+        $sock = IO::Socket::INET->new(
+            PeerAddr => $addr,
+            Proto    => 'tcp',
+        );
+    }
+    die "Couldn't connect to $addr\n" unless $sock;
+    return $sock;
 }
-die "Couldn't connect to $addr\n" unless $sock;
 
-if ($mode eq 'dump') {
-    my %items;
-    my $totalitems;
-
-    print $sock "stats items\r\n";
+my $sock = server_connect();
 
+if ($mode eq 'dump') {
+    print STDERR "Dumping memcache contents";
+    print STDERR " (limiting to $limit keys)" unless !$limit;
+    print STDERR "\n";
+    print $sock "lru_crawler metadump all\r\n";
+    my %keyexp;
+    my $keycount = 0;
     while (<$sock>) {
-        last if /^END/;
-        if (/^STAT items:(\d*):number (\d*)/) {
-            $items{$1} = $2;
-            $totalitems += $2;
-        }
-    }
-    print STDERR "Dumping memcache contents\n";
-    print STDERR "  Number of buckets: " . scalar(keys(%items)) . "\n";
-    print STDERR "  Number of items  : $totalitems\n";
-
-    foreach my $bucket (sort(keys(%items))) {
-        print STDERR "Dumping bucket $bucket - " . $items{$bucket} . " total items\n";
-        print $sock "stats cachedump $bucket $items{$bucket}\r\n";
-        my %keyexp;
-        while (<$sock>) {
-            last if /^END/;
-            # return format looks like this
-            # ITEM foo [6 b; 1176415152 s]
-            if (/^ITEM (\S+) \[.* (\d+) s\]/) {
-                $keyexp{$1} = $2;
+        last if /^END/ or ($limit and $keycount == $limit);
+        # return format looks like this
+        # key=foo exp=2147483647 la=1521046038 cas=717111 fetch=no cls=13 size=1232
+        if (/^key=(\S+) exp=(-?\d+) .*/) {
+            my $k = $1;
+            $k =~ s/%(.{2})/chr hex $1/eg;
+
+            if ($2 == -1) {
+                $keyexp{$k} = 0;
+            } else {
+                $keyexp{$k} = $2;
             }
         }
+        $keycount++;
+    }
 
-        foreach my $k (keys(%keyexp)) {
-            print $sock "get $k\r\n";
-            my $response = <$sock>;
-            if ($response =~ /VALUE (\S+) (\d+) (\d+)/) {
-                my $flags = $2;
-                my $len = $3;
-                my $val;
-                read $sock, $val, $len;
-                print "add $k $flags $keyexp{$k} $len\r\n$val\r\n";
-                # get the END
-                $_ = <$sock>;
-                $_ = <$sock>;
-            }
+    if ($limit) {
+        # Need to reopen the connection here to stop the metadump in
+        # case the key limit was reached.
+        #
+        # XXX: Once a limit on # of keys returned is introduced in
+        # `lru_crawler metadump`, this should be removed and the proper
+        # parameter passed in the query above.
+        close($sock);
+        $sock = server_connect();
+    }
+
+    foreach my $k (keys(%keyexp)) {
+        print $sock "get $k\r\n";
+        my $response = <$sock>;
+        if ($response =~ /VALUE (\S+) (\d+) (\d+)/) {
+            my $flags = $2;
+            my $len = $3;
+            my $val;
+            read $sock, $val, $len;
+            print "add $k $flags $keyexp{$k} $len\r\n$val\r\n";
+            # get the END
+            $_ = <$sock>;
+            $_ = <$sock>;
         }
     }
     exit;
diff --git a/scripts/memcached-tool.1 b/scripts/memcached-tool.1
index 6bb021b..a863bd4 100644
--- a/scripts/memcached-tool.1
+++ b/scripts/memcached-tool.1
@@ -57,9 +57,12 @@ Number of times the underlying slab class was unable to store a new item.
 Print general-purpose statistics of the daemon. Each line contains the name of
 the statistic and its value.
 .TP
-.B dump
+.B dump [limit]
 Make a partial dump of the cache written in the add statements of the
-memcached protocol.
+memcached protocol. If
+.B limit
+is given and is a strictly positive
+integer, then the dump is limited to that number of items.
 
 .SH SEE ALSO
 .BR memcached (1),
diff --git a/slabs.c b/slabs.c
index 200d575..2bcc350 100644
--- a/slabs.c
+++ b/slabs.c
@@ -8,6 +8,7 @@
  * memcached protocol.
  */
 #include "memcached.h"
+#include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/socket.h>
 #include <sys/resource.h>
@@ -98,6 +99,57 @@ unsigned int slabs_clsid(const size_t size) {
     return res;
 }
 
+#if defined(__linux__) && defined(MADV_HUGEPAGE)
+/* Function split out for better error path handling */
+static void * alloc_large_chunk_linux(const size_t limit)
+{
+    size_t pagesize = 0;
+    void *ptr = NULL;
+    FILE *fp;
+    int ret;
+
+    /* Get the size of huge pages */
+    fp = fopen("/proc/meminfo", "r");
+    if (fp != NULL) {
+        char buf[64];
+
+        while ((fgets(buf, sizeof(buf), fp)))
+            if (!strncmp(buf, "Hugepagesize:", 13)) {
+                ret = sscanf(buf + 13, "%zu\n", &pagesize);
+
+                /* meminfo huge page size is in KiBs */
+                pagesize <<= 10;
+            }
+        fclose(fp);
+    }
+
+    if (!pagesize) {
+        fprintf(stderr, "Failed to get supported huge page size\n");
+        return NULL;
+    }
+
+    if (settings.verbose > 1)
+        fprintf(stderr, "huge page size: %zu\n", pagesize);
+
+    /* This works because glibc simply uses mmap when the alignment is
+     * above a certain limit. */
+    ret = posix_memalign(&ptr, pagesize, limit);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to get aligned memory chunk: %d\n", ret);
+        return NULL;
+    }
+
+    ret = madvise(ptr, limit, MADV_HUGEPAGE);
+    if (ret < 0) {
+        fprintf(stderr, "Failed to set transparent hugepage hint: %d\n", ret);
+        free(ptr);
+        ptr = NULL;
+    }
+
+    return ptr;
+}
+#endif
+
 /**
  * Determines the chunk sizes and initializes the slab class descriptors
  * accordingly.
@@ -106,11 +158,24 @@ void slabs_init(const size_t limit, const double factor, const bool prealloc, co
     int i = POWER_SMALLEST - 1;
     unsigned int size = sizeof(item) + settings.chunk_size;
 
+    /* Some platforms use runtime transparent hugepages. If for any reason
+     * the initial allocation fails, the required settings do not persist
+     * for remaining allocations. As such it makes little sense to do slab
+     * preallocation. */
+    bool __attribute__ ((unused)) do_slab_prealloc = false;
+
     mem_limit = limit;
 
     if (prealloc) {
+#if defined(__linux__) && defined(MADV_HUGEPAGE)
+        mem_base = alloc_large_chunk_linux(mem_limit);
+        if (mem_base)
+            do_slab_prealloc = true;
+#else
         /* Allocate everything in a big chunk with malloc */
         mem_base = malloc(mem_limit);
+        do_slab_prealloc = true;
+#endif
         if (mem_base != NULL) {
             mem_current = mem_base;
             mem_avail = mem_limit;
@@ -161,7 +226,7 @@ void slabs_init(const size_t limit, const double factor, const bool prealloc, co
 
     }
 
-    if (prealloc) {
+    if (prealloc && do_slab_prealloc) {
         slabs_preallocate(power_largest);
     }
 }
@@ -315,7 +380,7 @@ static void *do_slabs_alloc(const size_t size, unsigned int id, uint64_t *total_
 }
 
 static void do_slabs_free_chunked(item *it, const size_t size) {
-    item_chunk *chunk = (item_chunk *) ITEM_data(it);
+    item_chunk *chunk = (item_chunk *) ITEM_schunk(it);
     slabclass_t *p;
 
     it->it_flags = ITEM_SLABBED;
@@ -339,7 +404,15 @@ static void do_slabs_free_chunked(item *it, const size_t size) {
     p->slots = it;
     p->sl_curr++;
     // TODO: macro
+#ifdef NEED_ALIGN
+    int total = it->nkey + 1 + it->nsuffix + sizeof(item) + sizeof(item_chunk);
+    if (total % 8 != 0) {
+        total += 8 - (total % 8);
+    }
+    p->requested -= total;
+#else
     p->requested -= it->nkey + 1 + it->nsuffix + sizeof(item) + sizeof(item_chunk);
+#endif
     if (settings.use_cas) {
         p->requested -= sizeof(uint64_t);
     }
@@ -948,7 +1021,7 @@ static int slab_rebalance_move(void) {
                         do_item_replace(it, new_it, hv);
                         /* Need to walk the chunks and repoint head  */
                         if (new_it->it_flags & ITEM_CHUNKED) {
-                            item_chunk *fch = (item_chunk *) ITEM_data(new_it);
+                            item_chunk *fch = (item_chunk *) ITEM_schunk(new_it);
                             fch->next->prev = fch;
                             while (fch) {
                                 fch->head = new_it;
diff --git a/storage.c b/storage.c
index 6e61cd8..45554cf 100644
--- a/storage.c
+++ b/storage.c
@@ -6,27 +6,18 @@
 #include <stdlib.h>
 #include <string.h>
 #include <limits.h>
+#include <ctype.h>
 
 #define PAGE_BUCKET_DEFAULT 0
 #define PAGE_BUCKET_COMPACT 1
 #define PAGE_BUCKET_CHUNKED 2
 #define PAGE_BUCKET_LOWTTL  3
 
-int lru_maintainer_store(void *storage, const int clsid) {
-    //int i;
+/*** WRITE FLUSH THREAD ***/
+
+static int storage_write(void *storage, const int clsid, const int item_age) {
     int did_moves = 0;
-    int item_age = settings.ext_item_age;
-    bool mem_limit_reached = false;
-    unsigned int chunks_free;
     struct lru_pull_tail_return it_info;
-    // FIXME: need to directly ask the slabber how big a class is
-    if (slabs_clsid(settings.ext_item_size) > clsid)
-        return 0;
-    chunks_free = slabs_available_chunks(clsid, &mem_limit_reached,
-            NULL, NULL);
-    // if we are low on chunks and no spare, push out early.
-    if (chunks_free < settings.ext_free_memchunks[clsid] && mem_limit_reached)
-        item_age = 0;
 
     it_info.it = NULL;
     lru_pull_tail(clsid, COLD_LRU, 0, LRU_PULL_RETURN_ITEM, 0, &it_info);
@@ -42,14 +33,7 @@ int lru_maintainer_store(void *storage, const int clsid) {
     uint32_t flags;
     if ((it->it_flags & ITEM_HDR) == 0 &&
             (item_age == 0 || current_time - it->time > item_age)) {
-        // FIXME: flag conversion again
-        if (settings.inline_ascii_response) {
-            flags = (uint32_t) strtoul(ITEM_suffix(it), (char **) NULL, 10);
-        } else if (it->nsuffix > 0) {
-            flags = *((uint32_t *)ITEM_suffix(it));
-        } else {
-            flags = 0;
-        }
+        FLAGS_CONV(settings.inline_ascii_response, it, flags);
         item *hdr_it = do_item_alloc(ITEM_key(it), it->nkey, flags, it->exptime, sizeof(item_hdr));
         /* Run the storage write understanding the start of the item is dirty.
          * We will fill it (time/exptime/etc) from the header item on read.
@@ -57,7 +41,7 @@ int lru_maintainer_store(void *storage, const int clsid) {
         if (hdr_it != NULL) {
             int bucket = (it->it_flags & ITEM_CHUNKED) ?
                 PAGE_BUCKET_CHUNKED : PAGE_BUCKET_DEFAULT;
-            // Compres soon to expire items into similar pages.
+            // Compress soon to expire items into similar pages.
             if (it->exptime - current_time < settings.ext_low_ttl) {
                 bucket = PAGE_BUCKET_LOWTTL;
             }
@@ -67,7 +51,9 @@ int lru_maintainer_store(void *storage, const int clsid) {
             // NOTE: when the item is read back in, the slab mover
             // may see it. Important to have refcount>=2 or ~ITEM_LINKED
             assert(it->refcount >= 2);
-            if (extstore_write_request(storage, bucket, &io) == 0) {
+            // NOTE: write bucket vs free page bucket will disambiguate once
+            // lowttl feature is better understood.
+            if (extstore_write_request(storage, bucket, bucket, &io) == 0) {
                 // cuddle the hash value into the time field so we don't have
                 // to recalculate it.
                 item *buf_it = (item *) io.buf;
@@ -76,12 +62,12 @@ int lru_maintainer_store(void *storage, const int clsid) {
                 // TODO: should be in items.c
                 if (it->it_flags & ITEM_CHUNKED) {
                     // Need to loop through the item and copy
-                    item_chunk *sch = (item_chunk *) ITEM_data(it);
+                    item_chunk *sch = (item_chunk *) ITEM_schunk(it);
                     int remain = orig_ntotal;
                     int copied = 0;
                     // copy original header
                     int hdrtotal = ITEM_ntotal(it) - it->nbytes;
-                    memcpy((char *)io.buf+32, (char *)it+32, hdrtotal - 32);
+                    memcpy((char *)io.buf+STORE_OFFSET, (char *)it+STORE_OFFSET, hdrtotal - STORE_OFFSET);
                     copied = hdrtotal;
                     // copy data in like it were one large object.
                     while (sch && remain) {
@@ -93,11 +79,11 @@ int lru_maintainer_store(void *storage, const int clsid) {
                         sch = sch->next;
                     }
                 } else {
-                    memcpy((char *)io.buf+32, (char *)it+32, io.len-32);
+                    memcpy((char *)io.buf+STORE_OFFSET, (char *)it+STORE_OFFSET, io.len-STORE_OFFSET);
                 }
                 // crc what we copied so we can do it sequentially.
                 buf_it->it_flags &= ~ITEM_LINKED;
-                buf_it->exptime = crc32c(0, (char*)io.buf+32, orig_ntotal-32);
+                buf_it->exptime = crc32c(0, (char*)io.buf+STORE_OFFSET, orig_ntotal-STORE_OFFSET);
                 extstore_write(storage, &io);
                 item_hdr *hdr = (item_hdr *) ITEM_data(hdr_it);
                 hdr->page_version = io.page_version;
@@ -125,6 +111,128 @@ int lru_maintainer_store(void *storage, const int clsid) {
     return did_moves;
 }
 
+static pthread_t storage_write_tid;
+static pthread_mutex_t storage_write_plock;
+#define WRITE_SLEEP_MAX 1000000
+#define WRITE_SLEEP_MIN 500
+
+static void *storage_write_thread(void *arg) {
+    void *storage = arg;
+    // NOTE: ignoring overflow since that would take years of uptime in a
+    // specific load pattern of never going to sleep.
+    unsigned int backoff[MAX_NUMBER_OF_SLAB_CLASSES] = {0};
+    unsigned int counter = 0;
+    useconds_t to_sleep = WRITE_SLEEP_MIN;
+    logger *l = logger_create();
+    if (l == NULL) {
+        fprintf(stderr, "Failed to allocate logger for storage compaction thread\n");
+        abort();
+    }
+
+    pthread_mutex_lock(&storage_write_plock);
+
+    while (1) {
+        // cache per-loop to avoid calls to the slabs_clsid() search loop
+        int min_class = slabs_clsid(settings.ext_item_size);
+        bool do_sleep = true;
+        counter++;
+        if (to_sleep > WRITE_SLEEP_MAX)
+            to_sleep = WRITE_SLEEP_MAX;
+
+        for (int x = 0; x < MAX_NUMBER_OF_SLAB_CLASSES; x++) {
+            bool did_move = false;
+            bool mem_limit_reached = false;
+            unsigned int chunks_free;
+            int item_age;
+            int target = settings.ext_free_memchunks[x];
+            if (min_class > x || (backoff[x] && (counter % backoff[x] != 0))) {
+                // Long sleeps means we should retry classes sooner.
+                if (to_sleep > WRITE_SLEEP_MIN * 10)
+                    backoff[x] /= 2;
+                continue;
+            }
+
+            // Avoid extra slab lock calls during heavy writing.
+            chunks_free = slabs_available_chunks(x, &mem_limit_reached,
+                    NULL, NULL);
+
+            // storage_write() will fail and cut loop after filling write buffer.
+            while (1) {
+                // if we are low on chunks and no spare, push out early.
+                if (chunks_free < target && mem_limit_reached) {
+                    item_age = 0;
+                } else {
+                    item_age = settings.ext_item_age;
+                }
+                if (storage_write(storage, x, item_age)) {
+                    chunks_free++; // Allow stopping if we've done enough this loop
+                    did_move = true;
+                    do_sleep = false;
+                    if (to_sleep > WRITE_SLEEP_MIN)
+                        to_sleep /= 2;
+                } else {
+                    break;
+                }
+            }
+
+            if (!did_move) {
+                backoff[x]++;
+            } else if (backoff[x]) {
+                backoff[x] /= 2;
+            }
+        }
+
+        // flip lock so we can be paused or stopped
+        pthread_mutex_unlock(&storage_write_plock);
+        if (do_sleep) {
+            usleep(to_sleep);
+            to_sleep *= 2;
+        }
+        pthread_mutex_lock(&storage_write_plock);
+    }
+    return NULL;
+}
+
+// TODO
+// logger needs logger_destroy() to exist/work before this is safe.
+/*int stop_storage_write_thread(void) {
+    int ret;
+    pthread_mutex_lock(&lru_maintainer_lock);
+    do_run_lru_maintainer_thread = 0;
+    pthread_mutex_unlock(&lru_maintainer_lock);
+    // WAKEUP SIGNAL
+    if ((ret = pthread_join(lru_maintainer_tid, NULL)) != 0) {
+        fprintf(stderr, "Failed to stop LRU maintainer thread: %s\n", strerror(ret));
+        return -1;
+    }
+    settings.lru_maintainer_thread = false;
+    return 0;
+}*/
+
+void storage_write_pause(void) {
+    pthread_mutex_lock(&storage_write_plock);
+}
+
+void storage_write_resume(void) {
+    pthread_mutex_unlock(&storage_write_plock);
+}
+
+int start_storage_write_thread(void *arg) {
+    int ret;
+
+    pthread_mutex_init(&storage_write_plock, NULL);
+    if ((ret = pthread_create(&storage_write_tid, NULL,
+        storage_write_thread, arg)) != 0) {
+        fprintf(stderr, "Can't create storage_write thread: %s\n",
+            strerror(ret));
+        return -1;
+    }
+
+    return 0;
+}
+
+/*** COMPACTOR ***/
+
 /* Fetch stats from the external storage system and decide to compact.
  * If we're more than half full, start skewing how aggressively to run
  * compaction, up to a desired target when all pages are full.
@@ -260,7 +368,7 @@ static void storage_compact_readback(void *storage, logger *l,
                 io.len = ntotal;
                 io.mode = OBJ_IO_WRITE;
                 for (tries = 10; tries > 0; tries--) {
-                    if (extstore_write_request(storage, PAGE_BUCKET_COMPACT, &io) == 0) {
+                    if (extstore_write_request(storage, PAGE_BUCKET_COMPACT, PAGE_BUCKET_COMPACT, &io) == 0) {
                         memcpy(io.buf, it, io.len);
                         extstore_write(storage, &io);
                         do_update = true;
@@ -456,4 +564,88 @@ int start_storage_compact_thread(void *arg) {
     return 0;
 }
 
+/*** UTILITY ***/
+// /path/to/file:100G:bucket1
+// FIXME: Modifies argument. copy instead?
+struct extstore_conf_file *storage_conf_parse(char *arg, unsigned int page_size) {
+    struct extstore_conf_file *cf = NULL;
+    char *b = NULL;
+    char *p = strtok_r(arg, ":", &b);
+    char unit = 0;
+    uint64_t multiplier = 0;
+    int base_size = 0;
+    if (p == NULL)
+        goto error;
+    // First arg is the filepath.
+    cf = calloc(1, sizeof(struct extstore_conf_file));
+    cf->file = strdup(p);
+
+    p = strtok_r(NULL, ":", &b);
+    if (p == NULL) {
+        fprintf(stderr, "must supply size to ext_path, ie: ext_path=/f/e:64m (M|G|T|P supported)\n");
+        goto error;
+    }
+    unit = tolower(p[strlen(p)-1]);
+    p[strlen(p)-1] = '\0';
+    // sigh.
+    switch (unit) {
+        case 'm':
+            multiplier = 1024 * 1024;
+            break;
+        case 'g':
+            multiplier = 1024 * 1024 * 1024;
+            break;
+        case 't':
+            multiplier = 1024 * 1024;
+            multiplier *= 1024 * 1024;
+            break;
+        case 'p':
+            multiplier = 1024 * 1024;
+            multiplier *= 1024 * 1024 * 1024;
+            break;
+    }
+    base_size = atoi(p);
+    multiplier *= base_size;
+    // page_count is nearest-but-not-larger-than pages * psize
+    cf->page_count = multiplier / page_size;
+    assert(page_size * cf->page_count <= multiplier);
+
+    // final token would be a default free bucket
+    p = strtok_r(NULL, ",", &b);
+    // TODO: We reuse the original DEFINES for now,
+    // but if lowttl gets split up this needs to be its own set.
+    if (p != NULL) {
+        if (strcmp(p, "compact") == 0) {
+            cf->free_bucket = PAGE_BUCKET_COMPACT;
+        } else if (strcmp(p, "lowttl") == 0) {
+            cf->free_bucket = PAGE_BUCKET_LOWTTL;
+        } else if (strcmp(p, "chunked") == 0) {
+            cf->free_bucket = PAGE_BUCKET_CHUNKED;
+        } else if (strcmp(p, "default") == 0) {
+            cf->free_bucket = PAGE_BUCKET_DEFAULT;
+        } else {
+            fprintf(stderr, "Unknown extstore bucket: %s\n", p);
+            goto error;
+        }
+    } else {
+        // TODO: is this necessary?
+        cf->free_bucket = PAGE_BUCKET_DEFAULT;
+    }
+
+    // TODO: disabling until compact algorithm is improved.
+    if (cf->free_bucket != PAGE_BUCKET_DEFAULT) {
+        fprintf(stderr, "ext_path only presently supports the default bucket\n");
+        goto error;
+    }
+
+    return cf;
+error:
+    if (cf) {
+        if (cf->file)
+            free(cf->file);
+        free(cf);
+    }
+    return NULL;
+}
+
 #endif
diff --git a/storage.h b/storage.h
index 7af6cc0..60f499b 100644
--- a/storage.h
+++ b/storage.h
@@ -1,9 +1,15 @@
 #ifndef STORAGE_H
 #define STORAGE_H
 
-int lru_maintainer_store(void *storage, const int clsid);
+int start_storage_write_thread(void *arg);
+void storage_write_pause(void);
+void storage_write_resume(void);
 int start_storage_compact_thread(void *arg);
 void storage_compact_pause(void);
 void storage_compact_resume(void);
+struct extstore_conf_file *storage_conf_parse(char *arg, unsigned int page_size);
+
+// Ignore pointers and header bits from the CRC
+#define STORE_OFFSET offsetof(item, nbytes)
 
 #endif
diff --git a/t/binary-extstore.t b/t/binary-extstore.t
index 390e26a..676d13b 100755
--- a/t/binary-extstore.t
+++ b/t/binary-extstore.t
@@ -17,7 +17,7 @@ if (!supports_extstore()) {
 
 $ext_path = "/tmp/extstore.$$";
 
-my $server = new_memcached("-m 64 -U 0 -o ext_page_size=8,ext_page_count=8,ext_wbuf_size=2,ext_threads=1,ext_io_depth=2,ext_item_size=512,ext_item_age=2,ext_recache_rate=10000,ext_max_frag=0.9,ext_path=$ext_path,no_lru_crawler,slab_automove=0");
+my $server = new_memcached("-m 64 -U 0 -o ext_page_size=8,ext_wbuf_size=2,ext_threads=1,ext_io_depth=2,ext_item_size=512,ext_item_age=2,ext_recache_rate=10000,ext_max_frag=0.9,ext_path=$ext_path:64m,no_lru_crawler,slab_automove=0");
 ok($server, "started the server");
 
 # Based almost 100% off testClient.py which is:
@@ -176,7 +176,15 @@ $set->('x', 10, 19, "somevalue");
         $set->("mfoo$_", 0, 19, $value);
     }
     sleep 4;
-    $empty->('mfoo1');
+    # FIXME: Need to sample through a few values, or fix eviction to be
+    # more accurate. On 32bit systems some pages unused to this point get
+    # filled after the first few items, then the eviction algo pulls those
+    # pages since they have the lowest version number, leaving older objects
+    # in memory and evicting newer ones.
+    for (1 .. ($keycount*3)) {
+        next unless $_ % 100 == 0;
+        eval { $mc->get("mfoo$_"); };
+    }
 
     my %s = $mc->stats('');
     cmp_ok($s{extstore_objects_evicted}, '>', 0);
diff --git a/t/binary-sasl.t b/t/binary-sasl.t
index 85ef069..e923584 100755
--- a/t/binary-sasl.t
+++ b/t/binary-sasl.t
@@ -13,7 +13,7 @@ use Test::More;
 
 if (supports_sasl()) {
     if ($ENV{'RUN_SASL_TESTS'}) {
-        plan tests => 33;
+        plan tests => 34;
     } else {
         plan skip_all => 'Skipping SASL tests';
         exit 0;
@@ -92,7 +92,7 @@ use constant RES_MAGIC        => 0x81;
 my $pwd=getcwd;
 $ENV{'SASL_CONF_PATH'} = "$pwd/t/sasl";
 
-my $server = new_memcached('-B binary -S ');
+my $server = new_memcached('-B binary -S -l 127.0.0.1 ');
 
 my $mc = MC::Client->new;
 
@@ -192,7 +192,9 @@ for my $dir (split(/:/, $ENV{PATH}),
     }
 }
 
-system("echo testpass | $saslpasswd_path -a memcached -c -p testuser");
+my $sasl_realm = 'memcached.realm';
+
+system("echo testpass | $saslpasswd_path -a memcached -u $sasl_realm -c -p testuser");
 
 $mc = MC::Client->new;
 
@@ -261,6 +263,11 @@ $empty->('x', 'somevalue');
     cmp_ok($status,'==',ERR_AUTH_ERROR, "error code matches");
 }
 
+{
+    my $mc = MC::Client->new;
+    is ($mc->sasl_step('testuser', 'testpass'), 0x20, "sasl_step_fails_no_segfault");
+}
+
 # check the SASL stats, make sure they track things correctly
 # note: the enabled or not is presence checked in stats.t
 
@@ -273,8 +280,8 @@ $empty->('x', 'somevalue');
 
 {
     my %stats = $mc->stats('');
-    is ($stats{'auth_cmds'}, 5, "auth commands counted");
-    is ($stats{'auth_errors'}, 3, "auth errors correct");
+    is ($stats{'auth_cmds'}, 6, "auth commands counted");
+    is ($stats{'auth_errors'}, 4, "auth errors correct");
 }
 
 
@@ -309,10 +316,17 @@ sub new {
 sub authenticate {
     my ($self, $user, $pass, $mech)= @_;
     $mech ||= 'PLAIN';
-    my $buf = sprintf("%c%s%c%s", 0, $user, 0, $pass);
+    my $buf = sprintf("%c%s@%s%c%s", 0, $user, $sasl_realm, 0, $pass);
     my ($status, $rv, undef) = $self->_do_command(::CMD_SASL_AUTH, $mech, $buf, '');
     return $status;
 }
+sub sasl_step {
+    my ($self, $user, $pass, $mech)= @_;
+    $mech ||= 'PLAIN';
+    my $buf = sprintf("%c%s@%s%c%s", 0, $user, $sasl_realm, 0, $pass);
+    my ($status, $rv, undef) = $self->_do_command(::CMD_SASL_STEP, $mech, $buf, '');
+    return $status;
+}
 sub list_mechs {
     my ($self)= @_;
     my ($status, $rv, undef) = $self->_do_command(::CMD_SASL_LIST_MECHS, '', '', '');
@@ -661,4 +675,3 @@ sub auth_error {
 unlink $sasldb;
 
 # vim: filetype=perl
-
diff --git a/t/chunked-extstore.t b/t/chunked-extstore.t
index ebd0f0b..3515f21 100644
--- a/t/chunked-extstore.t
+++ b/t/chunked-extstore.t
@@ -18,9 +18,26 @@ if (!supports_extstore()) {
 
 $ext_path = "/tmp/extstore.$$";
 
-my $server = new_memcached("-m 64 -U 0 -o ext_page_size=8,ext_page_count=8,ext_wbuf_size=2,ext_threads=1,ext_io_depth=2,ext_item_size=512,ext_item_age=2,ext_recache_rate=10000,ext_max_frag=0.9,ext_path=$ext_path,slab_chunk_max=16384,slab_automove=0");
+my $server = new_memcached("-m 64 -U 0 -o ext_page_size=8,ext_wbuf_size=2,ext_threads=1,ext_io_depth=2,ext_item_size=512,ext_item_age=2,ext_recache_rate=10000,ext_max_frag=0.9,ext_path=$ext_path:64m,slab_chunk_max=16384,slab_automove=0,ext_compact_under=1");
 my $sock = $server->sock;
 
+# Wait until all items have flushed
+sub wait_for_ext {
+    my $sum = 1;
+    while ($sum != 0) {
+        my $s = mem_stats($sock, "items");
+        $sum = 0;
+        for my $key (keys %$s) {
+            if ($key =~ m/items:(\d+):number/) {
+                # Ignore classes which can contain extstore items
+                next if $1 < 3;
+                $sum += $s->{$key};
+            }
+        }
+        sleep 1 if $sum != 0;
+    }
+}
+
 # We're testing to ensure item chaining doesn't corrupt or poorly overlap
 # data, so create a non-repeating pattern.
 my @parts = ();
@@ -58,7 +75,7 @@ for (1..5) {
         print $sock "set toast$_ 0 0 $biglen\r\n$big\r\n";
         is(scalar <$sock>, "STORED\r\n", "stored big");
     }
-    sleep 4;
+    wait_for_ext();
 
     for (1..40) {
         mem_get_is($sock, "toast$_", $big);
@@ -76,17 +93,19 @@ for (1..5) {
 
 # fill to eviction
 {
-    my $keycount = 1000;
+    my $keycount = 1250;
     for (1 .. $keycount) {
         print $sock "set mfoo$_ 0 0 $plen noreply\r\n$pattern\r\n";
+        wait_for_ext() if $_ % 500 == 0;
     }
-    sleep 6;
+    # because item_age is set to 2s.
+    wait_for_ext();
 
     my $stats = mem_stats($sock);
     cmp_ok($stats->{extstore_page_evictions}, '>', 0, 'at least one page evicted');
     cmp_ok($stats->{extstore_objects_evicted}, '>', 0, 'at least one object evicted');
     cmp_ok($stats->{extstore_bytes_evicted}, '>', 0, 'some bytes evicted');
-    is($stats->{extstore_pages_free}, 1, '1 page is free');
+    cmp_ok($stats->{extstore_pages_free}, '<', 2, 'most pages are used');
     is($stats->{miss_from_extstore}, 0, 'no misses');
 
     # original "pattern" key should be gone.
@@ -106,14 +125,18 @@ for (1..5) {
         print $sock "delete toast$_ noreply\r\n" if $_ % 2 == 0;
     }
 
-    for (1..1000) {
+    for (1..1250) {
         # Force a read so objects don't get skipped.
-        mem_get_is($sock, "mfoo$_", $pattern) if $_ % 2 == 1;
+        print $sock "add mfoo$_ 0 0 1 noreply\r\n1\r\n" if $_ % 2 == 1;
     }
-    for (1..1000) {
-        # Force a read so objects don't get skipped.
+    for (1..1250) {
+        # Delete lots of objects to trigger compaction.
         print $sock "delete mfoo$_ noreply\r\n" if $_ % 2 == 0;
     }
+    print $sock "extstore compact_under 4\r\n";
+    my $res = <$sock>;
+    print $sock "extstore drop_under 3\r\n";
+    $res = <$sock>;
 
     sleep 4;
 
@@ -122,7 +145,7 @@ for (1..5) {
     cmp_ok($stats->{extstore_compact_rescues}, '>', 0, 'some compaction rescues happened');
 
     # Some of the early items got evicted
-    for (100..1000) {
+    for (750..1250) {
         # everything should validate properly.
         mem_get_is($sock, "mfoo$_", $pattern) if $_ % 2 == 1;
     }
@@ -133,20 +156,12 @@ for (1..5) {
     print $sock "extstore recache_rate 1\r\n";
     is(scalar <$sock>, "OK\r\n", "upped recache rate");
 
-    for (800..1000) {
+    for (1150..1250) {
         mem_get_is($sock, "mfoo$_", $pattern) if $_ % 2 == 1;
     }
 
     my $stats = mem_stats($sock);
-    cmp_ok($stats->{recache_from_extstore}, '>', 100, 'recaching happening');
-
-    for (800..1000) {
-        mem_get_is($sock, "mfoo$_", $pattern) if $_ % 2 == 1;
-    }
-
-    my $stats2 = mem_stats($sock);
-    is($stats->{recache_from_extstore}, $stats2->{recache_from_extstore},
-        'values already recached');
+    cmp_ok($stats->{recache_from_extstore}, '>', 25, 'recaching happening');
 }
 
 done_testing();
diff --git a/t/error-extstore.t b/t/error-extstore.t
 new file mode 100644
index 0000000..6df1528
--- /dev/null
+++ b/t/error-extstore.t
@@ -0,0 +1,130 @@
+#!/usr/bin/perl
+# Test the "Error on get" path for extstore.
+# the entire error handling code for process_get_command() never worked, and
+# would infinite loop. get_extstore() can hit it sometimes.
+
+use strict;
+use warnings;
+
+use Test::More;
+use FindBin qw($Bin);
+use lib "$Bin/lib";
+use MemcachedTest;
+
+my $ext_path;
+
+if (!supports_extstore()) {
+    plan skip_all => 'extstore not enabled';
+    exit 0;
+}
+
+$ext_path = "/tmp/extstore.$$";
+
+my $server = new_memcached("-m 64 -I 4m -U 0 -o ext_page_size=8,ext_wbuf_size=8,ext_threads=1,ext_io_depth=2,ext_item_size=512,ext_item_age=2,ext_recache_rate=10000,ext_max_frag=0.9,ext_path=$ext_path:64m,slab_automove=0,ext_compact_under=1");
+my $sock = $server->sock;
+
+# Wait until all items have flushed
+sub wait_for_ext {
+    my $sum = 1;
+    while ($sum != 0) {
+        my $s = mem_stats($sock, "items");
+        $sum = 0;
+        for my $key (keys %$s) {
+            if ($key =~ m/items:(\d+):number/) {
+                # Ignore classes which can contain extstore items
+                next if $1 < 3;
+                $sum += $s->{$key};
+            }
+        }
+        sleep 1 if $sum != 0;
+    }
+}
+
+# We're testing to ensure item chaining doesn't corrupt or poorly overlap
+# data, so create a non-repeating pattern.
+my @parts = ();
+for (1 .. 8000) {
+    push(@parts, $_);
+}
+my $pattern = join(':', @parts);
+my $plen = length($pattern);
+
+# Set some large items and let them flush to extstore.
+for (1..5) {
+    my $size = 3000 * 1024;
+    my $data = "x" x $size;
+    print $sock "set foo$_ 0 0 $size\r\n$data\r\n";
+    my $res = <$sock>;
+    is($res, "STORED\r\n", "stored some big items");
+}
+
+wait_for_ext();
+
+{
+    my $long_key = "f" x 512;
+    print $sock "get foo1 foo2 foo3 $long_key\r\n";
+    ok(scalar <$sock> =~ /CLIENT_ERROR bad command line format/, 'long key fails');
+    my $stats = mem_stats($sock);
+    cmp_ok($stats->{get_aborted_extstore}, '>', 1, 'some extstore queries aborted');
+}
+
+# Disable automatic page balancing, then move enough pages that the large
+# items can no longer be loaded from extstore
+{
+    print $sock "slabs automove 0\r\n";
+    my $res = <$sock>;
+    my $source = 0;
+    while (1) {
+        print $sock "slabs reassign $source 1\r\n";
+        $res = <$sock>;
+        if ($res =~ m/NOSPARE/) {
+            $source = -1;
+            my $stats = mem_stats($sock, 'slabs');
+            for my $key (grep { /total_pages/ } keys %$stats) {
+                if ($key =~ m/(\d+):total_pages/) {
+                    next if $1 < 3;
+                    $source = $1 if $stats->{$key} > 1;
+                }
+            }
+            last if $source == -1;
+        }
+        select undef, undef, undef, 0.10;
+    }
+}
+
+# fetching the large keys should now fail.
+{
+    print $sock "get foo1\r\n";
+    my $res = <$sock>;
+    $res =~ s/[\r\n]//g;
+    is($res, 'SERVER_ERROR out of memory writing get response', 'can no longer read back item');
+    my $stats = mem_stats($sock);
+    is($stats->{get_oom_extstore}, 1, 'check extstore oom counter');
+}
+
+# Leaving this for future generations.
+# The process_get_command() function had several memory leaks.
+my $LEAK_TEST = 0;
+if ($LEAK_TEST) {
+    my $tries = 0;
+    while ($tries) {
+        print $sock "slabs reassign 1 39\r\n";
+        my $res = <$sock>;
+        if ($res =~ m/BUSY/) {
+            select undef, undef, undef, 0.10;
+        } else {
+            $tries--;
+        }
+    }
+    my $long_key = "f" x 512;
+    while (1) {
+        print $sock "get foo1 foo2 foo3 $long_key\r\n";
+        my $res = <$sock>;
+    }
+}
+
+done_testing();
+
+END {
+    unlink $ext_path if $ext_path;
+}
diff --git a/t/extstore-buckets.t b/t/extstore-buckets.t
index a2c1c90..e3027ad 100644
--- a/t/extstore-buckets.t
+++ b/t/extstore-buckets.t
@@ -17,7 +17,7 @@ if (!supports_extstore()) {
 
 $ext_path = "/tmp/extstore.$$";
 
-my $server = new_memcached("-m 256 -U 0 -o ext_page_size=8,ext_page_count=8,ext_wbuf_size=2,ext_threads=1,ext_io_depth=2,ext_item_size=512,ext_item_age=2,ext_recache_rate=10000,ext_max_frag=0,ext_path=$ext_path,ext_low_ttl=60,slab_automove=1");
+my $server = new_memcached("-m 256 -U 0 -o ext_page_size=8,ext_wbuf_size=2,ext_threads=1,ext_io_depth=2,ext_item_size=512,ext_item_age=2,ext_recache_rate=10000,ext_max_frag=0,ext_path=$ext_path:64m,ext_low_ttl=60,slab_automove=1");
 my $sock = $server->sock;
 
 my $value;
diff --git a/t/extstore-jbod.t b/t/extstore-jbod.t
 new file mode 100644
index 0000000..1618803
--- /dev/null
+++ b/t/extstore-jbod.t
@@ -0,0 +1,69 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+use Test::More;
+use FindBin qw($Bin);
+use lib "$Bin/lib";
+use MemcachedTest;
+use Data::Dumper qw/Dumper/;
+
+my $ext_path;
+my $ext_path2;
+
+if (!supports_extstore()) {
+    plan skip_all => 'extstore not enabled';
+    exit 0;
+}
+
+$ext_path = "/tmp/extstore1.$$";
+$ext_path2 = "/tmp/extstore2.$$";
+
+my $server = new_memcached("-m 256 -U 0 -o ext_page_size=8,ext_wbuf_size=2,ext_threads=1,ext_io_depth=2,ext_item_size=512,ext_item_age=2,ext_recache_rate=10000,ext_max_frag=0.9,ext_path=$ext_path:64m,ext_path=$ext_path2:96m,slab_automove=1");
+my $sock = $server->sock;
+
+my $value;
+{
+    my @chars = ("C".."Z");
+    for (1 .. 20000) {
+        $value .= $chars[rand @chars];
+    }
+}
+
+# fill some larger objects
+{
+    # interleave sets with 0 ttl vs long ttl's.
+    my $keycount = 3700;
+    for (1 .. $keycount) {
+        print $sock "set nfoo$_ 0 0 20000 noreply\r\n$value\r\n";
+        print $sock "set lfoo$_ 0 0 20000 noreply\r\n$value\r\n";
+    }
+    # wait for a flush
+    wait_ext_flush($sock);
+    # delete half
+    mem_get_is($sock, "nfoo1", $value);
+    for (1 .. $keycount) {
+        print $sock "delete lfoo$_ noreply\r\n";
+    }
+    print $sock "lru_crawler crawl all\r\n";
+    <$sock>;
+    sleep 10;
+    # fetch
+    # check extstore counters
+    my $stats = mem_stats($sock);
+    is($stats->{evictions}, 0, 'no RAM evictions');
+    cmp_ok($stats->{extstore_page_allocs}, '>', 0, 'at least one page allocated');
+    cmp_ok($stats->{extstore_objects_written}, '>', $keycount / 2, 'some objects written');
+    cmp_ok($stats->{extstore_bytes_written}, '>', length($value) * 2, 'some bytes written');
+    cmp_ok($stats->{get_extstore}, '>', 0, 'one object was fetched');
+    cmp_ok($stats->{extstore_objects_read}, '>', 0, 'one object read');
+    cmp_ok($stats->{extstore_bytes_read}, '>', length($value), 'some bytes read');
+    cmp_ok($stats->{extstore_page_reclaims}, '>', 1, 'at least two pages reclaimed');
+}
+
+done_testing();
+
+END {
+    unlink $ext_path if $ext_path;
+    unlink $ext_path2 if $ext_path2;
+}
diff --git a/t/extstore.t b/t/extstore.t
index df4ca05..1790a54 100644
--- a/t/extstore.t
+++ b/t/extstore.t
@@ -17,9 +17,27 @@ if (!supports_extstore()) {
 
 $ext_path = "/tmp/extstore.$$";
 
-my $server = new_memcached("-m 64 -U 0 -o ext_page_size=8,ext_page_count=8,ext_wbuf_size=2,ext_threads=1,ext_io_depth=2,ext_item_size=512,ext_item_age=2,ext_recache_rate=10000,ext_max_frag=0.9,ext_path=$ext_path,slab_automove=0");
+my $server = new_memcached("-m 64 -U 0 -o ext_page_size=8,ext_wbuf_size=2,ext_threads=1,ext_io_depth=2,ext_item_size=512,ext_item_age=2,ext_recache_rate=10000,ext_max_frag=0.9,ext_path=$ext_path:64m,slab_automove=0,ext_compact_under=1");
 my $sock = $server->sock;
 
+# Wait until all items have flushed
+sub wait_for_ext {
+    my $target = shift || 0;
+    my $sum = $target + 1;
+    while ($sum > $target) {
+        my $s = mem_stats($sock, "items");
+        $sum = 0;
+        for my $key (keys %$s) {
+            if ($key =~ m/items:(\d+):number/) {
+                # Ignore classes which can contain extstore items
+                next if $1 < 3;
+                $sum += $s->{$key};
+            }
+        }
+        sleep 1 if $sum > $target;
+    }
+}
+
 my $value;
 {
     my @chars = ("C".."Z");
@@ -47,7 +65,7 @@ mem_get_is($sock, "foo", "hi");
         print $sock "set nfoo$_ 0 0 20000 noreply\r\n$value\r\n";
     }
     # wait for a flush
-    sleep 4;
+    wait_for_ext();
     # fetch
     # TODO: Fetch back all values
     mem_get_is($sock, "nfoo1", $value);
@@ -83,22 +101,28 @@ mem_get_is($sock, "foo", "hi");
 
 # fill to eviction
 {
-    my $keycount = 3000;
+    my $keycount = 4000;
     for (1 .. $keycount) {
         print $sock "set mfoo$_ 0 0 20000 noreply\r\n$value\r\n";
+        # wait to avoid evictions
+        wait_for_ext(500) if ($_ % 2000 == 0);
     }
-    sleep 4;
+    # because item_age is set to 2s
+    wait_for_ext();
     my $stats = mem_stats($sock);
+    is($stats->{evictions}, 0, 'no evictions');
     is($stats->{miss_from_extstore}, 0, 'no misses');
-    mem_get_is($sock, "canary", undef);
+    # FIXME: test is flaky; something can rescue the canary because of a race
+    # condition. might need to roundtrip twice or disable compaction?
+    #mem_get_is($sock, "canary", undef);
 
     # check counters
     $stats = mem_stats($sock);
     cmp_ok($stats->{extstore_page_evictions}, '>', 0, 'at least one page evicted');
     cmp_ok($stats->{extstore_objects_evicted}, '>', 0, 'at least one object evicted');
     cmp_ok($stats->{extstore_bytes_evicted}, '>', 0, 'some bytes evicted');
-    is($stats->{extstore_pages_free}, 0, '0 pages are free');
-    is($stats->{miss_from_extstore}, 1, 'exactly one miss');
+    cmp_ok($stats->{extstore_pages_free}, '<', 2, 'few pages are free');
+    #is($stats->{miss_from_extstore}, 1, 'exactly one miss');
 
     # refresh some keys so rescues happen while drop_unread == 1.
     for (1 .. $keycount / 2) {
@@ -111,6 +135,10 @@ mem_get_is($sock, "foo", "hi");
     my $res = <$sock>;
     print $sock "extstore max_frag 0\r\n";
     $res = <$sock>;
+    print $sock "extstore compact_under 4\r\n";
+    $res = <$sock>;
+    print $sock "extstore drop_under 3\r\n";
+    $res = <$sock>;
     for (1 .. $keycount) {
         next unless $_ % 2 == 0;
         print $sock "delete mfoo$_ noreply\r\n";
@@ -131,7 +159,7 @@ mem_get_is($sock, "foo", "hi");
     for (1 .. $keycount) {
         print $sock "set bfoo$_ 0 0 20000 noreply\r\n$value\r\n";
     }
-    sleep 4;
+    wait_for_ext();
 
     # incr should be blocked.
     print $sock "incr bfoo1 1\r\n";
@@ -139,7 +167,7 @@ mem_get_is($sock, "foo", "hi");
 
     # append/prepend *could* work, but it would require pulling the item back in.
     print $sock "append bfoo1 0 0 2\r\nhi\r\n";
-    is(scalar <$sock>, "NOT_STORED\r\n", 'append falis');
+    is(scalar <$sock>, "NOT_STORED\r\n", 'append fails');
     print $sock "prepend bfoo1 0 0 2\r\nhi\r\n";
     is(scalar <$sock>, "NOT_STORED\r\n", 'prepend fails');
 }
diff --git a/t/flush-all.t b/t/flush-all.t
index e30d819..d9c536a 100755
--- a/t/flush-all.t
+++ b/t/flush-all.t
@@ -40,7 +40,7 @@ is(scalar <$sock>, "OK\r\n", "did flush_all in future");
 print $sock "set foo 0 0 4\r\n1234\r\n";
 is(scalar <$sock>, "STORED\r\n", "stored foo = '1234'");
 mem_get_is($sock, "foo", '1234');
-sleep(3);
+sleep(5);
 mem_get_is($sock, "foo", undef);
 
 print $sock "set foo 0 0 5\r\n12345\r\n";
diff --git a/t/issue_67.t b/t/issue_67.t
index b2d374f..1dbaba2 100644
--- a/t/issue_67.t
+++ b/t/issue_67.t
@@ -1,11 +1,12 @@
 #!/usr/bin/perl
 
 use strict;
-use Test::More tests => 22;
+use Test::More tests => 24;
 use FindBin qw($Bin);
 use lib "$Bin/lib";
 use MemcachedTest;
 use Carp qw(croak);
+use Socket qw(sockaddr_in INADDR_ANY PF_INET SOCK_STREAM);
 
 use Cwd;
 my $builddir = getcwd;
@@ -29,12 +30,25 @@ sub validate_port {
     if ($expected == -1) {
         ok(!defined($got), "$name expected no port, got $got");
     } elsif ($expected == 0) {
-        ok($got != 11211, "$name expected random port (got $got)");
+        ok(defined($got) && $got != 11211, "$name expected random port (got $got)");
     } else {
         is($got, $expected, "$name");
     }
 }
 
+sub skip_if_default_addr_in_use(&) {
+    my ($block) = @_;
+
+    socket(my $socket, PF_INET, SOCK_STREAM, 0) or die $!;
+    my $addr_in_use = !bind($socket, sockaddr_in(11211, INADDR_ANY));
+    close($socket);
+
+    SKIP: {
+        skip 'Default address is in use. Do you have a running instance?', 2 if $addr_in_use;
+        return $block->();
+    }
+}
+
 sub run_server {
     my ($args) = @_;
 
@@ -75,14 +89,13 @@ sub when {
     validate_port($name, $ports{'UDP INET'}, $expected_udp);
 }
 
-# Disabling the defaults since it conflicts with a running instance.
-# when('no arguments', '', 11211, 11211);
+skip_if_default_addr_in_use { when('no arguments', '', 11211, -1) };
 when('specifying tcp port', '-p 11212', 11212, -1);
 when('specifying udp port', '-U 11222', 11222, 11222);
-when('specifying tcp ephemeral port', '-p -1', 0, 0);
+when('specifying tcp ephemeral port', '-p -1', 0, -1);
 when('specifying udp ephemeral port', '-U -1', 0, 0);
 when('tcp port disabled', '-p 0', -1, -1);
-when('udp port disabled', '-U 0', 11211, -1);
+skip_if_default_addr_in_use { when('udp port disabled', '-U 0', 11211, -1) };
 when('specifying tcp and udp ports', '-p 11232 -U 11233', 11232, 11233);
 when('specifying tcp and disabling udp', '-p 11242 -U 0', 11242, -1);
 when('specifying udp and disabling tcp', '-p -1 -U 11252', 0, 11252);
diff --git a/t/lib/MemcachedTest.pm b/t/lib/MemcachedTest.pm
index 4e1da66..416daaf 100644
--- a/t/lib/MemcachedTest.pm
+++ b/t/lib/MemcachedTest.pm
@@ -14,13 +14,33 @@ my $builddir = getcwd;
 my @unixsockets = ();
 
 @EXPORT = qw(new_memcached sleep mem_get_is mem_gets mem_gets_is mem_stats
-             supports_sasl free_port supports_drop_priv supports_extstore);
+             supports_sasl free_port supports_drop_priv supports_extstore
+             wait_ext_flush);
 
 sub sleep {
     my $n = shift;
     select undef, undef, undef, $n;
 }
 
+# Wait until all items have flushed
+sub wait_ext_flush {
+    my $sock = shift;
+    my $target = shift || 0;
+    my $sum = $target + 1;
+    while ($sum > $target) {
+        my $s = mem_stats($sock, "items");
+        $sum = 0;
+        for my $key (keys %$s) {
+            if ($key =~ m/items:(\d+):number/) {
+                # Ignore classes which can contain extstore items
+                next if $1 < 3;
+                $sum += $s->{$key};
+            }
+        }
+        sleep 1 if $sum > $target;
+    }
+}
+
 sub mem_stats {
     my ($sock, $type) = @_;
     $type = $type ? " $type" : "";
diff --git a/t/lru-crawler.t b/t/lru-crawler.t
index 18375c2..4e94fb3 100644
--- a/t/lru-crawler.t
+++ b/t/lru-crawler.t
@@ -2,7 +2,7 @@
 
 use strict;
 use warnings;
-use Test::More tests => 221;
+use Test::More tests => 222;
 use FindBin qw($Bin);
 use lib "$Bin/lib";
 use MemcachedTest;
@@ -60,6 +60,18 @@ while (1) {
     is($items->{"items:1:crawler_reclaimed"}, 30, "slab1 has 30 reclaims");
 }
 
+# Check that crawler metadump works correctly.
+{
+    print $sock "lru_crawler metadump all\r\n";
+    my $count = 0;
+    while (<$sock>) {
+        last if /^(\.|END)/;
+        /^(key=) (\S+).*([^\r\n]+)/;
+        $count++;
+    }
+    is ($count, 60);
+}
+
 for (1 .. 30) {
     mem_get_is($sock, "ifoo$_", "ok");
     mem_get_is($sock, "lfoo$_", "ok");
diff --git a/t/lru-maintainer.t b/t/lru-maintainer.t
index ac2ba7b..04fa76a 100644
--- a/t/lru-maintainer.t
+++ b/t/lru-maintainer.t
@@ -56,6 +56,18 @@ for (my $key = 0; $key < 100; $key++) {
         # Items need two fetches to become active
         mem_get_is($sock, "canary", $value);
         mem_get_is($sock, "canary", $value);
+        $stats = mem_stats($sock);
+        # The maintainer thread needs to juggle a bit to actually rescue an
+        # item. If it's slow we could evict after resuming setting.
+        sleep 1;
+        for (0..4) {
+            my $s2 = mem_stats($sock);
+            if ($s2->{lru_maintainer_juggles} - $stats->{lru_maintainer_juggles} < 5) {
+                sleep 1;
+                next;
+            }
+            last;
+        }
     }
     print $sock "set key$key 0 0 66560\r\n$value\r\n";
     is(scalar <$sock>, "STORED\r\n", "stored key$key");
diff --git a/t/misbehave.t b/t/misbehave.t
 old mode 100644
 new mode 100755
index ccf88f5..13cb7f3
--- a/t/misbehave.t
+++ b/t/misbehave.t
@@ -3,6 +3,7 @@
 use strict;
 use Test::More;
 use FindBin qw($Bin);
+use Socket qw(MSG_PEEK MSG_DONTWAIT);
 use lib "$Bin/lib";
 use MemcachedTest;
 
@@ -13,8 +14,15 @@ if (supports_drop_priv()) {
     exit 0;
 }
 
-my $server = new_memcached();
+my $server = new_memcached('-o drop_privileges');
 my $sock = $server->sock;
 
 print $sock "misbehave\r\n";
-is(scalar <$sock>, "OK\r\n", "did not allow misbehaving");
+sleep(1);
+
+# check if the socket is dead now
+my $buff;
+my $ret = recv($sock, $buff, 1, MSG_PEEK | MSG_DONTWAIT);
+is($ret, undef, "did not allow misbehaving");
+
+$server->DESTROY();
diff --git a/thread.c b/thread.c
index d17a387..618ffac 100644
--- a/thread.c
+++ b/thread.c
@@ -139,22 +139,24 @@ void pause_threads(enum pause_thread_types type) {
     buf[0] = 0;
     switch (type) {
         case PAUSE_ALL_THREADS:
-            lru_maintainer_pause();
             slabs_rebalancer_pause();
+            lru_maintainer_pause();
             lru_crawler_pause();
 #ifdef EXTSTORE
             storage_compact_pause();
+            storage_write_pause();
 #endif
         case PAUSE_WORKER_THREADS:
             buf[0] = 'p';
             pthread_mutex_lock(&worker_hang_lock);
             break;
         case RESUME_ALL_THREADS:
-            lru_maintainer_resume();
             slabs_rebalancer_resume();
+            lru_maintainer_resume();
             lru_crawler_resume();
 #ifdef EXTSTORE
             storage_compact_resume();
+            storage_write_resume();
 #endif
         case RESUME_WORKER_THREADS:
             pthread_mutex_unlock(&worker_hang_lock);
@@ -625,7 +627,7 @@ void item_unlink(item *item) {
  * Does arithmetic on a numeric item value.
  */
 enum delta_result_type add_delta(conn *c, const char *key,
-                                 const size_t nkey, int incr,
+                                 const size_t nkey, bool incr,
                                  const int64_t delta, char *buf,
                                  uint64_t *cas) {
     enum delta_result_type ret;
diff --git a/timedrun.c b/timedrun.c
index 6888453..a869004 100644
--- a/timedrun.c
+++ b/timedrun.c
@@ -7,11 +7,11 @@
 
 #include <assert.h>
 
-static int caught = 0;
+volatile sig_atomic_t caught_sig = 0;
 
-static void caught_signal(int which)
+static void signal_handler(int which)
 {
-    caught = which;
+    caught_sig = which;
 }
 
 static int wait_for_process(pid_t pid)
@@ -21,7 +21,7 @@ static int wait_for_process(pid_t pid)
     int i = 0;
     struct sigaction sig_handler;
 
-    sig_handler.sa_handler = caught_signal;
+    sig_handler.sa_handler = signal_handler;
     sig_handler.sa_flags = 0;
 
     sigaction(SIGALRM, &sig_handler, NULL);
@@ -44,8 +44,8 @@ static int wait_for_process(pid_t pid)
             switch (i) {
             case 0:
                 /* On the first iteration, pass the signal through */
-                sig = caught > 0 ? caught : SIGTERM;
-                if (caught == SIGALRM) {
+                sig = caught_sig > 0 ? caught_sig : SIGTERM;
+                if (caught_sig == SIGALRM) {
                    fprintf(stderr, "Timeout.. killing the process\n");
                 }
                 break;
diff --git a/version.m4 b/version.m4
index 4a02156..ff2636d 100644
--- a/version.m4
+++ b/version.m4
@@ -1 +1 @@
-m4_define([VERSION_NUMBER], [1.5.6])
+m4_define([VERSION_NUMBER], [1.5.10])