Import wiredtiger-wiredtiger-2.5.0-92-gd56476d.tar.gz from wiredtiger branch mongodb-2.8

46 files changed, 902 insertions, 358 deletions

diff --git a/src/third_party/wiredtiger/dist/api_err.py b/src/third_party/wiredtiger/dist/api_err.py
index cb2c8cc588e..6c893c9af82 100644
--- a/src/third_party/wiredtiger/dist/api_err.py
+++ b/src/third_party/wiredtiger/dist/api_err.py
@@ -78,7 +78,7 @@ for line in open('../src/include/wiredtiger.in', 'r'):
 tfile.close()
 compare_srcfile(tmp_file, '../src/include/wiredtiger.in')
 
-# Output the wiredtiger_strerror code.
+# Output the wiredtiger_strerror and wiredtiger_sterror_r code.
 tmp_file = '__tmp'
 tfile = open(tmp_file, 'w')
 tfile.write('''/* DO NOT EDIT: automatically built by dist/api_err.py. */
@@ -86,18 +86,22 @@ tfile.write('''/* DO NOT EDIT: automatically built by dist/api_err.py. */
 #include "wt_internal.h"
 
 /*
- * wiredtiger_strerror --
- *\tReturn a string for any error value.
+ * Historically, there was only the wiredtiger_strerror call because the POSIX
+ * port didn't need anything more complex; Windows requires memory allocation
+ * of error strings, so we added the wiredtiger_strerror_r call. Because we
+ * want wiredtiger_strerror to continue to be as thread-safe as possible, errors
+ * are split into three categories: WiredTiger constant strings, system constant
+ * strings and Everything Else, and we check constant strings before Everything
+ * Else.
  */
-const char *
-wiredtiger_strerror(int error)
-{
-\tstatic char errbuf[64];
-\tchar *p;
-
-\tif (error == 0)
-\t\treturn ("Successful return: 0");
 
+/*
+ * __wiredtiger_error --
+ *\tReturn a constant string for the WiredTiger errors.
+ */
+static const char *
+__wiredtiger_error(int error)
+{
 \tswitch (error) {
 ''')
 
@@ -105,19 +109,51 @@ for err in errors:
     tfile.write('\tcase ' + err.name + ':\n')
     tfile.write('\t\treturn ("' + err.name + ': ' + err.desc + '");\n')
 
-tfile.write('''\
-\tdefault:
-\t\tif (error > 0 && (p = strerror(error)) != NULL)
-\t\t\treturn (p);
-\t\tbreak;
-\t}
-
-\t/*
-\t * !!!
-\t * Not thread-safe, but this is never supposed to happen.
-\t */
-\t(void)snprintf(errbuf, sizeof(errbuf), "Unknown error: %d", error);
-\treturn (errbuf);
+tfile.write('''\t}
+\treturn (NULL);
+}
+
+/*
+ * wiredtiger_strerror --
+ *\tReturn a string for any error value, non-thread-safe version.
+ */
+const char *
+wiredtiger_strerror(int error)
+{
+\tstatic char buf[128];
+\tconst char *p;
+
+\t/* Check for a constant string. */
+\tif ((p = __wiredtiger_error(error)) != NULL ||
+\t    (p = __wt_strerror(error)) != NULL)
+\t\treturn (p);
+
+\t/* Else, fill in the non-thread-safe static buffer. */
+\tif (wiredtiger_strerror_r(error, buf, sizeof(buf)) != 0)
+\t\t(void)snprintf(buf, sizeof(buf), "error return: %d", error);
+
+\treturn (buf);
+}
+
+/*
+ * wiredtiger_strerror_r --
+ *\tReturn a string for any error value, thread-safe version.
+ */
+int
+wiredtiger_strerror_r(int error, char *buf, size_t buflen)
+{
+\tconst char *p;
+
+\t/* Require at least 2 bytes, printable character and trailing nul. */
+\tif (buflen < 2)
+\t\treturn (ENOMEM);
+
+\t/* Check for a constant string. */
+\tif ((p = __wiredtiger_error(error)) != NULL ||
+\t    (p = __wt_strerror(error)) != NULL)
+\t\treturn (snprintf(buf, buflen, "%s", p) > 0 ? 0 : ENOMEM);
+
+\treturn (__wt_strerror_r(error, buf, buflen));
 }
 ''')
 tfile.close()
diff --git a/src/third_party/wiredtiger/dist/s_string.ok b/src/third_party/wiredtiger/dist/s_string.ok
index db1114b77de..d3717d27331 100644
--- a/src/third_party/wiredtiger/dist/s_string.ok
+++ b/src/third_party/wiredtiger/dist/s_string.ok
@@ -181,6 +181,7 @@ KV
 KVS
 Kanowski's
 Kounavis
+LANGID
 LEX
 LF
 LIBBZ
@@ -437,6 +438,7 @@ btmem
 btree
 btrees
 buf
+buflen
 bufs
 bufsz
 builtin
diff --git a/src/third_party/wiredtiger/dist/s_symbols.list b/src/third_party/wiredtiger/dist/s_symbols.list
index d3803bc3afa..8f469e94433 100644
--- a/src/third_party/wiredtiger/dist/s_symbols.list
+++ b/src/third_party/wiredtiger/dist/s_symbols.list
@@ -8,6 +8,7 @@ wiredtiger_pack_start
 wiredtiger_pack_str
 wiredtiger_pack_uint
 wiredtiger_strerror
+wiredtiger_strerror_r
 wiredtiger_struct_pack
 wiredtiger_struct_size
 wiredtiger_struct_unpack
diff --git a/src/third_party/wiredtiger/dist/s_tags b/src/third_party/wiredtiger/dist/s_tags
index 908b5eb7e0d..faed132d05b 100644
--- a/src/third_party/wiredtiger/dist/s_tags
+++ b/src/third_party/wiredtiger/dist/s_tags
@@ -35,10 +35,19 @@ ctags $flags ../src/include/*.in ../src/*/*.[chi] 2>/dev/null)
 rm -f tags
 ctags $flags ../include/*.in ../*/*.[chi] 2>/dev/null)
 
+# Link the tags file into place if we're at the right level.
+link_tag()
+{
+	if test -e ../include/tags; then
+		rm -f tags && ln -s ../include/tags .
+	fi
+}
+
 # Link to the tags file from standard build and source directories.
 dirs="`python -c 'import dist; dist.print_source_dirs()'` ../src/os_win"
 for i in $dirs; do
-	if ! expr "$i" : ".*/include" > /dev/null; then
-		(cd $i && rm -f tags && ln -s ../include/tags .)
+	if expr "$i" : ".*/include" > /dev/null; then
+		continue
 	fi
+	(cd $i && link_tag)
 done
diff --git a/src/third_party/wiredtiger/dist/stat_data.py b/src/third_party/wiredtiger/dist/stat_data.py
index a6a047fd10e..69e8d2ed21e 100644
--- a/src/third_party/wiredtiger/dist/stat_data.py
+++ b/src/third_party/wiredtiger/dist/stat_data.py
@@ -162,10 +162,14 @@ connection_stats = [
         'pages selected for eviction unable to be evicted'),
     CacheStat('cache_eviction_force',
         'pages evicted because they exceeded the in-memory maximum'),
+    CacheStat('cache_eviction_force_delete',
+        'pages evicted because they had chains of deleted items'),
     CacheStat('cache_eviction_force_fail',
         'failed eviction of pages that exceeded the in-memory maximum'),
     CacheStat('cache_eviction_hazard', 'hazard pointer blocked page eviction'),
     CacheStat('cache_eviction_internal', 'internal pages evicted'),
+    CacheStat('cache_eviction_maximum_page_size',
+        'maximum page size at eviction', 'max_aggregate,no_scale'),
     CacheStat('cache_eviction_queue_empty',
         'eviction server candidate queue empty when topping up'),
     CacheStat('cache_eviction_queue_not_empty',
diff --git a/src/third_party/wiredtiger/lang/java/src/com/wiredtiger/db/PackFormatInputStream.java b/src/third_party/wiredtiger/lang/java/src/com/wiredtiger/db/PackFormatInputStream.java
index c9d1c43d32d..c53938d0a58 100644
--- a/src/third_party/wiredtiger/lang/java/src/com/wiredtiger/db/PackFormatInputStream.java
+++ b/src/third_party/wiredtiger/lang/java/src/com/wiredtiger/db/PackFormatInputStream.java
@@ -85,7 +85,6 @@ public class PackFormatInputStream {
     protected char getType()
     throws WiredTigerPackingException {
         if (formatOff >= format.length()) {
-            System.err.println("Raw format is: " + format);
             throw new WiredTigerPackingException(
                 "No more fields in format.");
         }
diff --git a/src/third_party/wiredtiger/lang/java/src/com/wiredtiger/db/PackInputStream.java b/src/third_party/wiredtiger/lang/java/src/com/wiredtiger/db/PackInputStream.java
index 75bdb3119a9..a49b2e01f17 100644
--- a/src/third_party/wiredtiger/lang/java/src/com/wiredtiger/db/PackInputStream.java
+++ b/src/third_party/wiredtiger/lang/java/src/com/wiredtiger/db/PackInputStream.java
@@ -225,6 +225,7 @@ public class PackInputStream {
     public String getString()
     throws WiredTigerPackingException {
         int stringLength = 0;
+        int skipnull = 0;
         format.checkType('S', false);
         // Get the length for a fixed length string
         if (format.getType() != 'S') {
@@ -235,10 +236,11 @@ public class PackInputStream {
             // string length.
             for (; valueOff + stringLength < value.length &&
                     value[valueOff + stringLength] != 0; stringLength++) {}
+            skipnull = 1;
         }
         format.consume();
         String result = new String(value, valueOff, stringLength);
-        valueOff += stringLength + 1;
+        valueOff += stringLength + skipnull;
         return result;
     }
 
@@ -250,7 +252,7 @@ public class PackInputStream {
     private short unpackShort(boolean signed)
     throws WiredTigerPackingException {
         long ret = unpackLong(true);
-        if ((signed && (ret > Short.MAX_VALUE || ret > Short.MIN_VALUE)) ||
+        if ((signed && (ret > Short.MAX_VALUE || ret < Short.MIN_VALUE)) ||
                 (!signed && (short)ret < 0)) {
             throw new WiredTigerPackingException("Overflow unpacking short.");
         }
@@ -265,7 +267,7 @@ public class PackInputStream {
     private int unpackInt(boolean signed)
     throws WiredTigerPackingException {
         long ret = unpackLong(true);
-        if ((signed && (ret > Integer.MAX_VALUE || ret > Integer.MIN_VALUE)) ||
+        if ((signed && (ret > Integer.MAX_VALUE || ret < Integer.MIN_VALUE)) ||
                 (!signed && (int)ret < 0)) {
             throw new WiredTigerPackingException("Overflow unpacking integer.");
         }
diff --git a/src/third_party/wiredtiger/lang/java/src/com/wiredtiger/db/PackOutputStream.java b/src/third_party/wiredtiger/lang/java/src/com/wiredtiger/db/PackOutputStream.java
index 60f40564afd..e79b4c63498 100644
--- a/src/third_party/wiredtiger/lang/java/src/com/wiredtiger/db/PackOutputStream.java
+++ b/src/third_party/wiredtiger/lang/java/src/com/wiredtiger/db/PackOutputStream.java
@@ -174,13 +174,16 @@ public class PackOutputStream {
         char fieldFormat = format.getType();
         int stringLen = 0;
         int padBytes = 0;
+        int valLen = 0;
         // Strings have two possible encodings. A lower case 's' is not null
         // terminated, and has a length define in the format (default 1). An
         // upper case 'S' is variable length and has a null terminator.
         if (fieldFormat == 's') {
             stringLen = format.getLengthFromFormat(true);
-            if (stringLen > value.length()) {
-                padBytes = stringLen - value.length();
+            valLen = value.length();
+            if (stringLen > valLen) {
+                padBytes = stringLen - valLen;
+                stringLen = valLen;
             }
         } else {
             stringLen = value.length();
diff --git a/src/third_party/wiredtiger/lang/java/wiredtiger.i b/src/third_party/wiredtiger/lang/java/wiredtiger.i
index a922a7a6b2e..09290a70c67 100644
--- a/src/third_party/wiredtiger/lang/java/wiredtiger.i
+++ b/src/third_party/wiredtiger/lang/java/wiredtiger.i
@@ -652,6 +652,19 @@ WT_ASYNC_CALLBACK javaApiAsyncHandler = {javaAsyncHandler};
 	}
 
 	/**
+	 * Append a record number to the async_op's key.
+	 *
+	 * \param value The value to append
+	 * \return This async_op object, so put calls can be chained.
+	 */
+	public AsyncOp putKeyRecord(long value)
+	throws WiredTigerPackingException {
+		keyUnpacker = null;
+		keyPacker.addRecord(value);
+		return this;
+	}
+
+	/**
 	 * Append a short integer to the async_op's key.
 	 *
 	 * \param value The value to append
@@ -744,6 +757,19 @@ WT_ASYNC_CALLBACK javaApiAsyncHandler = {javaAsyncHandler};
 	}
 
 	/**
+	 * Append a record number to the async_op's value.
+	 *
+	 * \param value The value to append
+	 * \return This async_op object, so put calls can be chained.
+	 */
+	public AsyncOp putValueRecord(long value)
+	throws WiredTigerPackingException {
+		valueUnpacker = null;
+		valuePacker.addRecord(value);
+		return this;
+	}
+
+	/**
 	 * Append a short integer to the async_op's value.
 	 *
 	 * \param value The value to append
@@ -835,6 +861,16 @@ WT_ASYNC_CALLBACK javaApiAsyncHandler = {javaAsyncHandler};
 	}
 
 	/**
+	 * Retrieve a record number from the async_op's key.
+	 *
+	 * \return The requested value.
+	 */
+	public long getKeyRecord()
+	throws WiredTigerPackingException {
+		return getKeyUnpacker().getRecord();
+	}
+
+	/**
 	 * Retrieve a short integer from the async_op's key.
 	 *
 	 * \return The requested value.
@@ -920,6 +956,16 @@ WT_ASYNC_CALLBACK javaApiAsyncHandler = {javaAsyncHandler};
 	}
 
 	/**
+	 * Retrieve a record number from the async_op's value.
+	 *
+	 * \return The requested value.
+	 */
+	public long getValueRecord()
+	throws WiredTigerPackingException {
+		return getValueUnpacker().getRecord();
+	}
+
+	/**
 	 * Retrieve a short integer from the async_op's value.
 	 *
 	 * \return The requested value.
@@ -1202,6 +1248,18 @@ WT_ASYNC_CALLBACK javaApiAsyncHandler = {javaAsyncHandler};
 	}
 
 	/**
+	 * Append a record number to the cursor's key.
+	 *
+	 * \param value The value to append
+	 * \return This cursor object, so put calls can be chained.
+	 */
+	public Cursor putKeyRecord(long value)
+	throws WiredTigerPackingException {
+		keyPacker.addRecord(value);
+		return this;
+	}
+
+	/**
 	 * Append a short integer to the cursor's key.
 	 *
 	 * \param value The value to append
@@ -1288,6 +1346,18 @@ WT_ASYNC_CALLBACK javaApiAsyncHandler = {javaAsyncHandler};
 	}
 
 	/**
+	 * Append a record number to the cursor's value.
+	 *
+	 * \param value The value to append
+	 * \return This cursor object, so put calls can be chained.
+	 */
+	public Cursor putValueRecord(long value)
+	throws WiredTigerPackingException {
+		valuePacker.addRecord(value);
+		return this;
+	}
+
+	/**
 	 * Append a short integer to the cursor's value.
 	 *
 	 * \param value The value to append
@@ -1377,6 +1447,16 @@ WT_ASYNC_CALLBACK javaApiAsyncHandler = {javaAsyncHandler};
 	}
 
 	/**
+	 * Retrieve a record number from the cursor's key.
+	 *
+	 * \return The requested value.
+	 */
+	public long getKeyRecord()
+	throws WiredTigerPackingException {
+		return keyUnpacker.getRecord();
+	}
+
+	/**
 	 * Retrieve a short integer from the cursor's key.
 	 *
 	 * \return The requested value.
@@ -1462,6 +1542,16 @@ WT_ASYNC_CALLBACK javaApiAsyncHandler = {javaAsyncHandler};
 	}
 
 	/**
+	 * Retrieve a record number from the cursor's value.
+	 *
+	 * \return The requested value.
+	 */
+	public long getValueRecord()
+	throws WiredTigerPackingException {
+		return valueUnpacker.getRecord();
+	}
+
+	/**
 	 * Retrieve a short integer from the cursor's value.
 	 *
 	 * \return The requested value.
@@ -1801,7 +1891,8 @@ err:		if (ret != 0)
 		if ((ret = $self->open_cursor($self, uri, to_dup, config, &cursor)) != 0)
 			goto err;
 
-		cursor->flags |= WT_CURSTD_RAW;
+		if ((cursor->flags & WT_CURSTD_DUMP_JSON) == 0)
+			cursor->flags |= WT_CURSTD_RAW;
 
 		if ((ret = __wt_calloc_def((WT_SESSION_IMPL *)cursor->session,
 			    1, &jcb)) != 0)
diff --git a/src/third_party/wiredtiger/lang/python/wiredtiger.i b/src/third_party/wiredtiger/lang/python/wiredtiger.i
index 974118d0f61..de5afb0a0fa 100644
--- a/src/third_party/wiredtiger/lang/python/wiredtiger.i
+++ b/src/third_party/wiredtiger/lang/python/wiredtiger.i
@@ -339,7 +339,9 @@ retry:
 	if (result != 0 && result != EBUSY)
 		SWIG_ERROR_IF_NOT_SET(result);
         else if (result == EBUSY) {
+		SWIG_PYTHON_THREAD_BEGIN_ALLOW;
                 __wt_sleep(0, 10000);
+		SWIG_PYTHON_THREAD_END_ALLOW;
                 goto retry;
         }
 }
@@ -361,10 +363,19 @@ retry:
 }
 %enddef
 
-/* Cursor compare can return any of -1, 0, 1 or WT_NOTFOUND. */
+/* Cursor compare can return any of -1, 0, 1. */
 %define COMPARE_OK(m)
 %exception m {
 	$action
+	if (result < -1 || result > 1)
+		SWIG_ERROR_IF_NOT_SET(result);
+}
+%enddef
+
+/* Cursor compare can return any of -1, 0, 1 or WT_NOTFOUND. */
+%define COMPARE_NOTFOUND_OK(m)
+%exception m {
+	$action
 	if ((result < -1 || result > 1) && result != WT_NOTFOUND)
 		SWIG_ERROR_IF_NOT_SET(result);
 }
@@ -379,7 +390,7 @@ NOTFOUND_OK(__wt_cursor::search)
 NOTFOUND_OK(__wt_cursor::update)
 
 COMPARE_OK(__wt_cursor::compare)
-COMPARE_OK(__wt_cursor::search_near)
+COMPARE_NOTFOUND_OK(__wt_cursor::search_near)
 
 /* Lastly, some methods need no (additional) error checking. */
 %exception __wt_connection::get_home;
diff --git a/src/third_party/wiredtiger/src/btree/bt_debug.c b/src/third_party/wiredtiger/src/btree/bt_debug.c
index 4de94277364..af9f6a669f2 100644
--- a/src/third_party/wiredtiger/src/btree/bt_debug.c
+++ b/src/third_party/wiredtiger/src/btree/bt_debug.c
@@ -408,11 +408,13 @@ __debug_tree_shape_info(WT_PAGE *page)
 
 	v = page->memory_footprint;
 	if (v >= WT_GIGABYTE)
-		snprintf(buf, sizeof(buf), "(%" PRIu64 "G)", v / WT_GIGABYTE);
+		snprintf(buf, sizeof(buf),
+		    "(%p %" PRIu64 "G)", page, v / WT_GIGABYTE);
 	else if (v >= WT_MEGABYTE)
-		snprintf(buf, sizeof(buf), "(%" PRIu64 "M)", v / WT_MEGABYTE);
+		snprintf(buf, sizeof(buf),
+		    "(%p %" PRIu64 "M)", page, v / WT_MEGABYTE);
 	else
-		snprintf(buf, sizeof(buf), "(%" PRIu64 ")", v);
+		snprintf(buf, sizeof(buf), "(%p %" PRIu64 ")", page, v);
 	return (buf);
 }
 
@@ -429,16 +431,16 @@ __debug_tree_shape_worker(WT_DBG *ds, WT_PAGE *page, int level)
 	session = ds->session;
 
 	if (page->type == WT_PAGE_ROW_INT || page->type == WT_PAGE_COL_INT) {
-		__dmsg(ds, "%*s" "I" "%s\n",
-		    level, " ", __debug_tree_shape_info(page));
+		__dmsg(ds, "%*s" "I" "%d %s\n",
+		    level * 3, " ", level, __debug_tree_shape_info(page));
 		WT_INTL_FOREACH_BEGIN(session, page, ref) {
 			if (ref->state == WT_REF_MEM)
 				__debug_tree_shape_worker(
-				    ds, ref->page, level + 3);
+				    ds, ref->page, level + 1);
 		} WT_INTL_FOREACH_END;
 	} else
-		__dmsg(ds, "%*s" "L" "%s\n",
-		    level, " ", __debug_tree_shape_info(page));
+		__dmsg(ds, "%*s" "L" " %s\n",
+		    level * 3, " ", __debug_tree_shape_info(page));
 }
 
 /*
@@ -458,8 +460,7 @@ __wt_debug_tree_shape(
 	if (page == NULL)
 		page = S2BT(session)->root.page;
 
-	WT_WITH_PAGE_INDEX(session,
-	    __debug_tree_shape_worker(ds, page, 0));
+	WT_WITH_PAGE_INDEX(session, __debug_tree_shape_worker(ds, page, 1));
 
 	__dmsg_wrapup(ds);
 	return (0);
diff --git a/src/third_party/wiredtiger/src/btree/bt_delete.c b/src/third_party/wiredtiger/src/btree/bt_delete.c
index c97ea176c97..622dfb1b294 100644
--- a/src/third_party/wiredtiger/src/btree/bt_delete.c
+++ b/src/third_party/wiredtiger/src/btree/bt_delete.c
@@ -207,6 +207,9 @@ __wt_delete_page_skip(WT_SESSION_IMPL *session, WT_REF *ref)
 {
 	int skip;
 
+	if (ref->state != WT_REF_DELETED)
+		return (0);
+
 	/*
 	 * Deleted pages come from two sources: either it's a fast-delete as
 	 * described above, or the page has been emptied by other operations
@@ -225,11 +228,14 @@ __wt_delete_page_skip(WT_SESSION_IMPL *session, WT_REF *ref)
 	 * the page could switch to an in-memory state at any time.  Lock down
 	 * the structure, just to be safe.
 	 */
+	if (ref->page_del == NULL)
+		return (1);
+
 	if (!WT_ATOMIC_CAS4(ref->state, WT_REF_DELETED, WT_REF_LOCKED))
 		return (0);
 
-	skip = ref->page_del == NULL ||
-	    __wt_txn_visible(session, ref->page_del->txnid) ? 1 : 0;
+	skip = (ref->page_del == NULL ||
+	    __wt_txn_visible(session, ref->page_del->txnid));
 
 	WT_PUBLISH(ref->state, WT_REF_DELETED);
 	return (skip);
diff --git a/src/third_party/wiredtiger/src/btree/bt_page.c b/src/third_party/wiredtiger/src/btree/bt_page.c
index 181ffdb3736..561e1c19218 100644
--- a/src/third_party/wiredtiger/src/btree/bt_page.c
+++ b/src/third_party/wiredtiger/src/btree/bt_page.c
@@ -37,8 +37,11 @@ __evict_force_check(WT_SESSION_IMPL *session, WT_PAGE *page)
 	    page->type != WT_PAGE_ROW_LEAF)
 		return (0);
 
-	/* Eviction may be turned off, although that's rare. */
-	if (F_ISSET(btree, WT_BTREE_NO_EVICTION))
+	/*
+	 * Eviction may be turned off (although that's rare), or we may be in
+	 * the middle of a checkpoint.
+	 */
+	if (F_ISSET(btree, WT_BTREE_NO_EVICTION) || btree->checkpointing)
 		return (0);
 
 	/*
@@ -128,7 +131,13 @@ __wt_page_in_func(WT_SESSION_IMPL *session, WT_REF *ref, uint32_t flags
 			    force_attempts < 10 &&
 			    __evict_force_check(session, page)) {
 				++force_attempts;
-				WT_RET(__wt_page_release(session, ref, flags));
+				if ((ret = __wt_page_release_busy(
+				    session, ref, flags)) == EBUSY) {
+					/* If forced eviction fails, stall. */
+					ret = 0;
+					wait_cnt += 1000;
+				} else
+					WT_RET(ret);
 				WT_STAT_FAST_CONN_INCR(
 				    session, page_forcible_evict_blocked);
 				break;
diff --git a/src/third_party/wiredtiger/src/btree/bt_split.c b/src/third_party/wiredtiger/src/btree/bt_split.c
index 1c62391f722..70d0758dede 100644
--- a/src/third_party/wiredtiger/src/btree/bt_split.c
+++ b/src/third_party/wiredtiger/src/btree/bt_split.c
@@ -9,15 +9,6 @@
 #include "wt_internal.h"
 
 /*
- * Tuning; global variables to allow the binary to be patched, we don't yet have
- * any real understanding of what might be useful to surface to applications.
- */
-static u_int __split_deepen_max_internal_image = 100;
-static u_int __split_deepen_min_child = 10;
-static u_int __split_deepen_per_child = 100;
-static u_int __split_deepen_split_child = 100;
-
-/*
  * Track allocation increments, matching the cache calculations, which add an
  * estimate of allocation overhead to every object.
  */
@@ -177,45 +168,57 @@ __split_safe_free(WT_SESSION_IMPL *session, int exclusive, void *p, size_t s)
 }
 
 /*
+ * Tuning; global variables to allow the binary to be patched, we don't yet have
+ * any real understanding of what might be useful to surface to applications.
+ */
+static u_int __split_deepen_min_child = 10000;
+static u_int __split_deepen_per_child = 100;
+
+/*
  * __split_should_deepen --
  *	Return if we should deepen the tree.
  */
 static int
-__split_should_deepen(WT_SESSION_IMPL *session, WT_PAGE *page)
+__split_should_deepen(
+    WT_SESSION_IMPL *session, WT_REF *ref, uint32_t *childrenp)
 {
 	WT_PAGE_INDEX *pindex;
+	WT_PAGE *page;
 
-	/*
-	 * Splits are based on either the number of child pages that will be
-	 * created by the split (splitting an internal page that will be slow
-	 * to search), or by the memory footprint of the parent page (avoiding
-	 * an internal page that will eat up all of the cache and put eviction
-	 * pressure on the system).
-	 */
+	*childrenp = 0;
+
+	page = ref->page;
 	pindex = WT_INTL_INDEX_COPY(page);
 
 	/*
 	 * Deepen the tree if the page's memory footprint is larger than the
-	 * maximum size for a page in memory.  We need an absolute minimum
-	 * number of entries in order to split the page: if there is a single
-	 * huge key, splitting won't help.
+	 * maximum size for a page in memory (presumably putting eviction
+	 * pressure on the cache).
 	 */
-	if (page->memory_footprint > S2BT(session)->maxmempage &&
-	    pindex->entries >= __split_deepen_min_child)
-		return (1);
+	if (page->memory_footprint < S2BT(session)->maxmempage)
+		return (0);
 
 	/*
-	 * Deepen the tree if the page's memory footprint is at least N
-	 * times the maximum internal page size chunk in the backing file and
-	 * the split will result in at least N children in the newly created
-	 * intermediate layer.
+	 * Ensure the page has enough entries to make it worth splitting and
+	 * we get a significant payback (in the case of a set of large keys,
+	 * splitting won't help).
 	 */
-	if (page->memory_footprint >
-	    __split_deepen_max_internal_image * S2BT(session)->maxintlpage &&
-	    pindex->entries >=
-	    (__split_deepen_per_child * __split_deepen_split_child))
+	if (pindex->entries > __split_deepen_min_child) {
+		*childrenp = pindex->entries / __split_deepen_per_child;
 		return (1);
+	}
 
+	/*
+	 * The root is a special-case: if it's putting cache pressure on the
+	 * system, split it even if there are only a few entries, we can't
+	 * push it out of memory.  Sanity check: if the root page is too big
+	 * with less than 100 keys, there are huge keys and/or a too-small
+	 * cache, there's not much to do.
+	 */
+	if (__wt_ref_is_root(ref) && pindex->entries > 100) {
+		*childrenp = pindex->entries / 10;
+		return (1);
+	}
 	return (0);
 }
 
@@ -383,7 +386,7 @@ __split_verify_intl_key_order(WT_SESSION_IMPL *session, WT_PAGE *page)
  *	Split an internal page in-memory, deepening the tree.
  */
 static int
-__split_deepen(WT_SESSION_IMPL *session, WT_PAGE *parent)
+__split_deepen(WT_SESSION_IMPL *session, WT_PAGE *parent, uint32_t children)
 {
 	WT_DECL_RET;
 	WT_PAGE *child;
@@ -391,7 +394,7 @@ __split_deepen(WT_SESSION_IMPL *session, WT_PAGE *parent)
 	WT_REF **alloc_refp;
 	WT_REF *child_ref, **child_refp, *parent_ref, **parent_refp, *ref;
 	size_t child_incr, parent_decr, parent_incr, size;
-	uint32_t children, chunk, i, j, remain, slots;
+	uint32_t chunk, i, j, remain, slots;
 	int panic;
 	void *p;
 
@@ -401,13 +404,6 @@ __split_deepen(WT_SESSION_IMPL *session, WT_PAGE *parent)
 
 	pindex = WT_INTL_INDEX_COPY(parent);
 
-	/*
-	 * Create N children, unless we are dealing with a large page without
-	 * many entries, in which case split into the minimum number of pages.
-	 */
-	children = WT_MAX(pindex->entries / __split_deepen_per_child,
-	    __split_deepen_min_child);
-
 	WT_STAT_FAST_CONN_INCR(session, cache_eviction_deepen);
 	WT_ERR(__wt_verbose(session, WT_VERB_SPLIT,
 	    "%p: %" PRIu32 " elements, splitting into %" PRIu32 " children",
@@ -717,10 +713,11 @@ __split_multi_inmem(
 	/*
 	 * We modified the page above, which will have set the first dirty
 	 * transaction to the last transaction current running.  However, the
-	 * updates we installed may be older than that.  Inherit the first
-	 * dirty transaction from the original page.
+	 * updates we installed may be older than that.  Set the first dirty
+	 * transaction to an impossibly old value so this page is never skipped
+	 * in a checkpoint.
 	 */
-	page->modify->first_dirty_txn = orig->modify->first_dirty_txn;
+	page->modify->first_dirty_txn = WT_TXN_FIRST;
 
 err:	/* Free any resources that may have been cached in the cursor. */
 	WT_TRET(__wt_btcur_close(&cbt));
@@ -813,17 +810,20 @@ __split_parent(WT_SESSION_IMPL *session, WT_REF *ref, WT_REF **ref_new,
     int exclusive, int ref_discard)
 {
 	WT_DECL_RET;
+	WT_IKEY *ikey;
 	WT_PAGE *parent;
 	WT_PAGE_INDEX *alloc_index, *pindex;
-	WT_REF **alloc_refp, *parent_ref;
+	WT_REF **alloc_refp, *next_ref, *parent_ref;
 	size_t size;
-	uint32_t i, j, parent_entries, result_entries;
+	uint32_t children, i, j;
+	uint32_t deleted_entries, parent_entries, result_entries;
 	int complete, hazard, locked;
 
 	parent = NULL;			/* -Wconditional-uninitialized */
-	alloc_index = NULL;
+	alloc_index = pindex = NULL;
 	parent_ref = NULL;
 	complete = hazard = locked = 0;
+	parent_entries = 0;
 
 	/*
 	 * Get a page-level lock on the parent to single-thread splits into the
@@ -864,7 +864,29 @@ __split_parent(WT_SESSION_IMPL *session, WT_REF *ref, WT_REF **ref_new,
 
 	pindex = WT_INTL_INDEX_COPY(parent);
 	parent_entries = pindex->entries;
-	result_entries = (parent_entries - 1) + new_entries;
+
+	/*
+	 * Remove any refs to deleted pages while we are splitting, we have
+	 * the internal page locked down, and are copying the refs into a new
+	 * array anyway.  Switch them to the special split state, so that any
+	 * reading thread will restart.
+	 */
+	for (i = 0, deleted_entries = 0; i < parent_entries; ++i) {
+		next_ref = pindex->index[i];
+		WT_ASSERT(session, next_ref->state != WT_REF_SPLIT);
+		if (next_ref->state == WT_REF_DELETED &&
+		    next_ref->page_del == NULL &&
+		    WT_ATOMIC_CAS4(next_ref->state,
+		    WT_REF_DELETED, WT_REF_SPLIT))
+			deleted_entries++;
+	}
+
+	/*
+	 * The final entry count consists of: The original count, plus any
+	 * new pages, less any refs we are removing because they only
+	 * contained deleted items, less 1 for the page being replaced.
+	 */
+	result_entries = (parent_entries + new_entries) - (deleted_entries + 1);
 
 	/*
 	 * Allocate and initialize a new page index array for the parent, then
@@ -876,8 +898,9 @@ __split_parent(WT_SESSION_IMPL *session, WT_REF *ref, WT_REF **ref_new,
 	WT_MEMSIZE_ADD(parent_incr, size);
 	alloc_index->index = (WT_REF **)(alloc_index + 1);
 	alloc_index->entries = result_entries;
-	for (alloc_refp = alloc_index->index, i = 0; i < parent_entries; ++i)
-		if (pindex->index[i] == ref)
+	for (alloc_refp = alloc_index->index, i = 0; i < parent_entries; ++i) {
+		next_ref = pindex->index[i];
+		if (next_ref == ref)
 			for (j = 0; j < new_entries; ++j) {
 				ref_new[j]->home = parent;
 				*alloc_refp++ = ref_new[j];
@@ -889,8 +912,26 @@ __split_parent(WT_SESSION_IMPL *session, WT_REF *ref, WT_REF **ref_new,
 				 */
 				ref_new[j] = NULL;
 			}
-		else
-			*alloc_refp++ = pindex->index[i];
+		else if (next_ref->state == WT_REF_SPLIT) {
+			/*
+			 * We're discarding a deleted reference.
+			 * Free any resources it holds.
+			 */
+			if (parent->type == WT_PAGE_ROW_INT) {
+				WT_TRET(__split_ovfl_key_cleanup(
+				    session, parent, next_ref));
+				ikey = __wt_ref_key_instantiated(next_ref);
+				if (ikey != NULL)
+					WT_TRET(__split_safe_free(session, 0,
+					    ikey,
+					    sizeof(WT_IKEY) + ikey->size));
+			}
+
+			WT_TRET(__split_safe_free(
+			    session, 0, next_ref, sizeof(WT_REF)));
+		} else
+			*alloc_refp++ = next_ref;
+	}
 
 	/*
 	 * Update the parent page's index: this update makes the split visible
@@ -977,11 +1018,30 @@ __split_parent(WT_SESSION_IMPL *session, WT_REF *ref, WT_REF **ref_new,
 	 *	Do the check here because we've just grown the parent page and
 	 * are holding it locked.
 	 */
-	if (ret == 0 && !exclusive && __split_should_deepen(session, parent))
+	if (ret == 0 && !exclusive &&
+	    !F_ISSET_ATOMIC(parent, WT_PAGE_REFUSE_DEEPEN) &&
+	    __split_should_deepen(session, parent_ref, &children)) {
+		/*
+		 * XXX
+		 * Temporary hack to avoid a bug where the root page is split
+		 * even when it's no longer doing any good.
+		 */
+		uint64_t __a, __b;
+		__a = parent->memory_footprint;
 		WT_WITH_PAGE_INDEX(session,
-		    ret = __split_deepen(session, parent));
+		    ret = __split_deepen(session, parent, children));
+		__b = parent->memory_footprint;
+		if (__b * 2 >= __a)
+			F_SET_ATOMIC(parent, WT_PAGE_REFUSE_DEEPEN);
+	}
 
-err:	if (locked)
+err:	if (!complete)
+		for (i = 0; i < parent_entries; ++i) {
+			next_ref = pindex->index[i];
+			if (next_ref->state == WT_REF_SPLIT)
+				next_ref->state = WT_REF_DELETED;
+		}
+	if (locked)
 		F_CLR_ATOMIC(parent, WT_PAGE_SPLITTING);
 
 	if (hazard)
@@ -1137,10 +1197,11 @@ __wt_split_insert(WT_SESSION_IMPL *session, WT_REF *ref, int *splitp)
 	/*
 	 * We modified the page above, which will have set the first dirty
 	 * transaction to the last transaction current running.  However, the
-	 * updates we installed may be older than that.  Inherit the first
-	 * dirty transaction from the original page.
+	 * updates we installed may be older than that.  Set the first dirty
+	 * transaction to an impossibly old value so this page is never skipped
+	 * in a checkpoint.
 	 */
-	right->modify->first_dirty_txn = page->modify->first_dirty_txn;
+	right->modify->first_dirty_txn = WT_TXN_FIRST;
 
 	/*
 	 * Calculate how much memory we're moving: figure out how deep the skip
diff --git a/src/third_party/wiredtiger/src/btree/bt_walk.c b/src/third_party/wiredtiger/src/btree/bt_walk.c
index c74a7177401..a2b2a6bb7c8 100644
--- a/src/third_party/wiredtiger/src/btree/bt_walk.c
+++ b/src/third_party/wiredtiger/src/btree/bt_walk.c
@@ -208,6 +208,12 @@ restart:	/*
 					break;
 			} else if (LF_ISSET(WT_READ_TRUNCATE)) {
 				/*
+				 * Avoid pulling a deleted page back in to try
+				 * to delete it again.
+				 */
+				if (__wt_delete_page_skip(session, ref))
+					break;
+				/*
 				 * If deleting a range, try to delete the page
 				 * without instantiating it.
 				 */
@@ -242,8 +248,7 @@ restart:	/*
 				 * If iterating a cursor, try to skip deleted
 				 * pages that are visible to us.
 				 */
-				if (ref->state == WT_REF_DELETED &&
-				    __wt_delete_page_skip(session, ref))
+				if (__wt_delete_page_skip(session, ref))
 					break;
 			}
 
diff --git a/src/third_party/wiredtiger/src/conn/api_strerror.c b/src/third_party/wiredtiger/src/conn/api_strerror.c
index caf536b24f7..396ae7a3e0f 100644
--- a/src/third_party/wiredtiger/src/conn/api_strerror.c
+++ b/src/third_party/wiredtiger/src/conn/api_strerror.c
@@ -3,18 +3,22 @@
 #include "wt_internal.h"
 
 /*
- * wiredtiger_strerror --
- *	Return a string for any error value.
+ * Historically, there was only the wiredtiger_strerror call because the POSIX
+ * port didn't need anything more complex; Windows requires memory allocation
+ * of error strings, so we added the wiredtiger_strerror_r call. Because we
+ * want wiredtiger_strerror to continue to be as thread-safe as possible, errors
+ * are split into three categories: WiredTiger constant strings, system constant
+ * strings and Everything Else, and we check constant strings before Everything
+ * Else.
  */
-const char *
-wiredtiger_strerror(int error)
-{
-	static char errbuf[64];
-	char *p;
-
-	if (error == 0)
-		return ("Successful return: 0");
 
+/*
+ * __wiredtiger_error --
+ *	Return a constant string for the WiredTiger errors.
+ */
+static const char *
+__wiredtiger_error(int error)
+{
 	switch (error) {
 	case WT_ROLLBACK:
 		return ("WT_ROLLBACK: conflict between concurrent operations");
@@ -28,16 +32,49 @@ wiredtiger_strerror(int error)
 		return ("WT_PANIC: WiredTiger library panic");
 	case WT_RESTART:
 		return ("WT_RESTART: restart the operation (internal)");
-	default:
-		if (error > 0 && (p = strerror(error)) != NULL)
-			return (p);
-		break;
 	}
+	return (NULL);
+}
+
+/*
+ * wiredtiger_strerror --
+ *	Return a string for any error value, non-thread-safe version.
+ */
+const char *
+wiredtiger_strerror(int error)
+{
+	static char buf[128];
+	const char *p;
+
+	/* Check for a constant string. */
+	if ((p = __wiredtiger_error(error)) != NULL ||
+	    (p = __wt_strerror(error)) != NULL)
+		return (p);
+
+	/* Else, fill in the non-thread-safe static buffer. */
+	if (wiredtiger_strerror_r(error, buf, sizeof(buf)) != 0)
+		(void)snprintf(buf, sizeof(buf), "error return: %d", error);
+
+	return (buf);
+}
+
+/*
+ * wiredtiger_strerror_r --
+ *	Return a string for any error value, thread-safe version.
+ */
+int
+wiredtiger_strerror_r(int error, char *buf, size_t buflen)
+{
+	const char *p;
+
+	/* Require at least 2 bytes, printable character and trailing nul. */
+	if (buflen < 2)
+		return (ENOMEM);
+
+	/* Check for a constant string. */
+	if ((p = __wiredtiger_error(error)) != NULL ||
+	    (p = __wt_strerror(error)) != NULL)
+		return (snprintf(buf, buflen, "%s", p) > 0 ? 0 : ENOMEM);
 
-	/*
-	 * !!!
-	 * Not thread-safe, but this is never supposed to happen.
-	 */
-	(void)snprintf(errbuf, sizeof(errbuf), "Unknown error: %d", error);
-	return (errbuf);
+	return (__wt_strerror_r(error, buf, buflen));
 }
diff --git a/src/third_party/wiredtiger/src/conn/conn_cache.c b/src/third_party/wiredtiger/src/conn/conn_cache.c
index cf129531dd4..91f82a5105b 100644
--- a/src/third_party/wiredtiger/src/conn/conn_cache.c
+++ b/src/third_party/wiredtiger/src/conn/conn_cache.c
@@ -144,6 +144,8 @@ __wt_cache_stats_update(WT_SESSION_IMPL *session)
 	WT_STAT_SET(stats, cache_bytes_inuse, __wt_cache_bytes_inuse(cache));
 	WT_STAT_SET(stats, cache_pages_inuse, __wt_cache_pages_inuse(cache));
 	WT_STAT_SET(stats, cache_bytes_dirty, cache->bytes_dirty);
+	WT_STAT_SET(stats,
+	    cache_eviction_maximum_page_size, cache->evict_max_page_size);
 	WT_STAT_SET(stats, cache_pages_dirty, cache->pages_dirty);
 }
 
diff --git a/src/third_party/wiredtiger/src/cursor/cur_ds.c b/src/third_party/wiredtiger/src/cursor/cur_ds.c
index c8b8f6c4547..2cb791de85d 100644
--- a/src/third_party/wiredtiger/src/cursor/cur_ds.c
+++ b/src/third_party/wiredtiger/src/cursor/cur_ds.c
@@ -478,7 +478,6 @@ __wt_curds_open(
 	cursor = &data_source->iface;
 	*cursor = iface;
 	cursor->session = &session->iface;
-	F_SET(cursor, WT_CURSTD_DATA_SOURCE);
 
 	/*
 	 * XXX
diff --git a/src/third_party/wiredtiger/src/cursor/cur_log.c b/src/third_party/wiredtiger/src/cursor/cur_log.c
index 04ab1e2a14a..e3089e9fb83 100644
--- a/src/third_party/wiredtiger/src/cursor/cur_log.c
+++ b/src/third_party/wiredtiger/src/cursor/cur_log.c
@@ -150,6 +150,7 @@ static int
 __curlog_kv(WT_SESSION_IMPL *session, WT_CURSOR *cursor)
 {
 	WT_CURSOR_LOG *cl;
+	WT_ITEM item;
 	uint32_t fileid, key_count, opsize, optype;
 
 	cl = (WT_CURSOR_LOG *)cursor;
@@ -180,11 +181,37 @@ __curlog_kv(WT_SESSION_IMPL *session, WT_CURSOR *cursor)
 	 * The log cursor sets the LSN and step count as the cursor key and
 	 * and log record related data in the value.  The data in the value
 	 * contains any operation key/value that was in the log record.
+	 * For the special case that the caller needs the result in raw form,
+	 * we create packed versions of the key/value.
 	 */
-	__wt_cursor_set_key(cursor, cl->cur_lsn->file, cl->cur_lsn->offset,
-	    key_count);
-	__wt_cursor_set_value(cursor, cl->txnid, cl->rectype, optype,
-	    fileid, cl->opkey, cl->opvalue);
+	if (FLD_ISSET(cursor->flags, WT_CURSTD_RAW)) {
+		memset(&item, 0, sizeof(item));
+		WT_RET(wiredtiger_struct_size((WT_SESSION *)session,
+		    &item.size, LOGC_KEY_FORMAT, cl->cur_lsn->file,
+		    cl->cur_lsn->offset, key_count));
+		WT_RET(__wt_realloc(session, NULL, item.size, &cl->packed_key));
+		item.data = cl->packed_key;
+		WT_RET(wiredtiger_struct_pack((WT_SESSION *)session,
+		    cl->packed_key, item.size, LOGC_KEY_FORMAT,
+		    cl->cur_lsn->file, cl->cur_lsn->offset, key_count));
+		__wt_cursor_set_key(cursor, &item);
+
+		WT_RET(wiredtiger_struct_size((WT_SESSION *)session,
+		    &item.size, LOGC_VALUE_FORMAT, cl->txnid, cl->rectype,
+		    optype, fileid, cl->opkey, cl->opvalue));
+		WT_RET(__wt_realloc(session, NULL, item.size,
+		    &cl->packed_value));
+		item.data = cl->packed_value;
+		WT_RET(wiredtiger_struct_pack((WT_SESSION *)session,
+		    cl->packed_value, item.size, LOGC_VALUE_FORMAT, cl->txnid,
+		    cl->rectype, optype, fileid, cl->opkey, cl->opvalue));
+		__wt_cursor_set_value(cursor, &item);
+	} else {
+		__wt_cursor_set_key(cursor, cl->cur_lsn->file,
+		    cl->cur_lsn->offset, key_count);
+		__wt_cursor_set_value(cursor, cl->txnid, cl->rectype, optype,
+		    fileid, cl->opkey, cl->opvalue);
+	}
 	return (0);
 }
 
@@ -295,6 +322,8 @@ __curlog_close(WT_CURSOR *cursor)
 	__wt_scr_free(session, &cl->logrec);
 	__wt_scr_free(session, &cl->opkey);
 	__wt_scr_free(session, &cl->opvalue);
+	__wt_free(session, cl->packed_key);
+	__wt_free(session, cl->packed_value);
 	WT_TRET(__wt_cursor_close(cursor));
 
 err:	API_END_RET(session, ret);
diff --git a/src/third_party/wiredtiger/src/evict/evict_lru.c b/src/third_party/wiredtiger/src/evict/evict_lru.c
index 60a5f82f233..a4ae0aaf55b 100644
--- a/src/third_party/wiredtiger/src/evict/evict_lru.c
+++ b/src/third_party/wiredtiger/src/evict/evict_lru.c
@@ -437,7 +437,7 @@ __evict_pass(WT_SESSION_IMPL *session)
 	WT_EVICT_WORKER *worker;
 	int loop;
 	uint32_t flags;
-	uint64_t bytes_inuse, pages_evicted;
+	uint64_t bytes_inuse, dirty_target_size, pages_evicted, target_size;
 
 	conn = S2C(session);
 	cache = conn->cache;
@@ -465,9 +465,16 @@ __evict_pass(WT_SESSION_IMPL *session)
 		if (loop > 10)
 			LF_SET(WT_EVICT_PASS_AGGRESSIVE);
 
-		/* Start a worker if we have capacity and the cache is full. */
+		/*
+		 * Start a worker if we have capacity and we haven't reached
+		 * the eviction targets.
+		 */
 		bytes_inuse = __wt_cache_bytes_inuse(cache);
-		if (bytes_inuse > conn->cache_size &&
+		target_size = (conn->cache_size * cache->eviction_target) / 100;
+		dirty_target_size =
+		    (conn->cache_size * cache->eviction_dirty_target) / 100;
+		if ((bytes_inuse > target_size ||
+		    cache->bytes_dirty > dirty_target_size) &&
 		    conn->evict_workers < conn->evict_workers_max) {
 			WT_RET(__wt_verbose(session, WT_VERB_EVICTSERVER,
 			    "Starting evict worker: %"PRIu32"\n",
diff --git a/src/third_party/wiredtiger/src/evict/evict_page.c b/src/third_party/wiredtiger/src/evict/evict_page.c
index aca3dc11ee9..b3a6f718ca2 100644
--- a/src/third_party/wiredtiger/src/evict/evict_page.c
+++ b/src/third_party/wiredtiger/src/evict/evict_page.c
@@ -21,12 +21,15 @@ static void __evict_excl_clear(WT_SESSION_IMPL *);
 int
 __wt_evict(WT_SESSION_IMPL *session, WT_REF *ref, int exclusive)
 {
+	WT_CONNECTION_IMPL *conn;
 	WT_DECL_RET;
 	WT_PAGE *page;
 	WT_PAGE_MODIFY *mod;
 	WT_TXN_STATE *txn_state;
 	int forced_eviction, inmem_split, istree;
 
+	conn = S2C(session);
+
 	page = ref->page;
 	forced_eviction = (page->read_gen == WT_READGEN_OLDEST);
 	inmem_split = istree = 0;
@@ -40,7 +43,7 @@ __wt_evict(WT_SESSION_IMPL *session, WT_REF *ref, int exclusive)
 	 */
 	txn_state = WT_SESSION_TXN_STATE(session);
 	if (txn_state->snap_min == WT_TXN_NONE)
-		txn_state->snap_min = S2C(session)->txn_global.oldest_id;
+		txn_state->snap_min = conn->txn_global.oldest_id;
 	else
 		txn_state = NULL;
 
@@ -75,6 +78,14 @@ __wt_evict(WT_SESSION_IMPL *session, WT_REF *ref, int exclusive)
 		WT_STAT_FAST_DATA_INCR(session, cache_eviction_internal);
 	}
 
+	/*
+	 * Track the largest page size seen at eviction, it tells us something
+	 * about our ability to force pages out before they're larger than the
+	 * cache.
+	 */
+	if (page->memory_footprint > conn->cache->evict_max_page_size)
+		conn->cache->evict_max_page_size = page->memory_footprint;
+
 	/* Discard any subtree rooted in this page. */
 	if (istree)
 		WT_WITH_PAGE_INDEX(session,
@@ -119,8 +130,8 @@ done:	session->excl_next = 0;
 		txn_state->snap_min = WT_TXN_NONE;
 
 	if ((inmem_split || (forced_eviction && ret == EBUSY)) &&
-	    !F_ISSET(S2C(session)->cache, WT_EVICT_WOULD_BLOCK)) {
-		F_SET(S2C(session)->cache, WT_EVICT_WOULD_BLOCK);
+	    !F_ISSET(conn->cache, WT_EVICT_WOULD_BLOCK)) {
+		F_SET(conn->cache, WT_EVICT_WOULD_BLOCK);
 		WT_TRET(__wt_evict_server_wake(session));
 	}
 
diff --git a/src/third_party/wiredtiger/src/include/btmem.h b/src/third_party/wiredtiger/src/include/btmem.h
index e1fc72677c5..dd10e522412 100644
--- a/src/third_party/wiredtiger/src/include/btmem.h
+++ b/src/third_party/wiredtiger/src/include/btmem.h
@@ -550,9 +550,10 @@ struct __wt_page {
 #define	WT_PAGE_DISK_ALLOC	0x02	/* Disk image in allocated memory */
 #define	WT_PAGE_DISK_MAPPED	0x04	/* Disk image in mapped memory */
 #define	WT_PAGE_EVICT_LRU	0x08	/* Page is on the LRU queue */
-#define	WT_PAGE_SCANNING	0x10	/* Obsolete updates are being scanned */
-#define	WT_PAGE_SPLITTING	0x20	/* An internal page is growing */
+#define	WT_PAGE_REFUSE_DEEPEN	0x10	/* Don't deepen the tree at this page */
+#define	WT_PAGE_SCANNING	0x20	/* Obsolete updates are being scanned */
 #define	WT_PAGE_SPLIT_INSERT	0x40	/* A leaf page was split for append */
+#define	WT_PAGE_SPLITTING	0x80	/* An internal page is growing */
 	uint8_t flags_atomic;		/* Atomic flags, use F_*_ATOMIC */
 };
 
diff --git a/src/third_party/wiredtiger/src/include/btree.i b/src/third_party/wiredtiger/src/include/btree.i
index a333e4af565..d30ee46486a 100644
--- a/src/third_party/wiredtiger/src/include/btree.i
+++ b/src/third_party/wiredtiger/src/include/btree.i
@@ -165,65 +165,6 @@ __wt_cache_page_evict(WT_SESSION_IMPL *session, WT_PAGE *page)
 }
 
 /*
- * __wt_cache_read_gen --
- *      Get the current read generation number.
- */
-static inline uint64_t
-__wt_cache_read_gen(WT_SESSION_IMPL *session)
-{
-	return (S2C(session)->cache->read_gen);
-}
-
-/*
- * __wt_cache_read_gen_incr --
- *      Increment the current read generation number.
- */
-static inline void
-__wt_cache_read_gen_incr(WT_SESSION_IMPL *session)
-{
-	++S2C(session)->cache->read_gen;
-}
-
-/*
- * __wt_cache_read_gen_set --
- *      Get the read generation to store in a page.
- */
-static inline uint64_t
-__wt_cache_read_gen_set(WT_SESSION_IMPL *session)
-{
-	/*
-	 * We return read-generations from the future (where "the future" is
-	 * measured by increments of the global read generation).  The reason
-	 * is because when acquiring a new hazard pointer for a page, we can
-	 * check its read generation, and if the read generation isn't less
-	 * than the current global generation, we don't bother updating the
-	 * page.  In other words, the goal is to avoid some number of updates
-	 * immediately after each update we have to make.
-	 */
-	return (__wt_cache_read_gen(session) + WT_READGEN_STEP);
-}
-
-/*
- * __wt_cache_pages_inuse --
- *	Return the number of pages in use.
- */
-static inline uint64_t
-__wt_cache_pages_inuse(WT_CACHE *cache)
-{
-	return (cache->pages_inmem - cache->pages_evict);
-}
-
-/*
- * __wt_cache_bytes_inuse --
- *	Return the number of bytes in use.
- */
-static inline uint64_t
-__wt_cache_bytes_inuse(WT_CACHE *cache)
-{
-	return (cache->bytes_inmem - cache->bytes_evict);
-}
-
-/*
  * __wt_page_evict_soon --
  *      Set a page to be evicted as soon as possible.
  */
@@ -917,16 +858,16 @@ __wt_ref_info(WT_SESSION_IMPL *session,
 }
 
 /*
- * __wt_page_release --
- *	Release a reference to a page.
+ * __wt_page_release_busy --
+ *	Release a reference to a page, fail if busy during forced eviction.
  */
 static inline int
-__wt_page_release(WT_SESSION_IMPL *session, WT_REF *ref, uint32_t flags)
+__wt_page_release_busy(WT_SESSION_IMPL *session, WT_REF *ref, uint32_t flags)
 {
 	WT_BTREE *btree;
 	WT_DECL_RET;
 	WT_PAGE *page;
-	int locked;
+	int locked, too_big;
 
 	btree = S2BT(session);
 
@@ -938,6 +879,8 @@ __wt_page_release(WT_SESSION_IMPL *session, WT_REF *ref, uint32_t flags)
 		return (0);
 	page = ref->page;
 
+	too_big = (page->memory_footprint < btree->maxmempage) ? 0 : 1;
+
 	/*
 	 * Attempt to evict pages with the special "oldest" read generation.
 	 *
@@ -970,12 +913,19 @@ __wt_page_release(WT_SESSION_IMPL *session, WT_REF *ref, uint32_t flags)
 		return (ret);
 
 	(void)WT_ATOMIC_ADD4(btree->evict_busy, 1);
-	if ((ret = __wt_evict_page(session, ref)) == 0)
-		WT_STAT_FAST_CONN_INCR(session, cache_eviction_force);
-	else {
+	if ((ret = __wt_evict_page(session, ref)) == 0) {
+		if (too_big)
+			WT_STAT_FAST_CONN_INCR(session, cache_eviction_force);
+		else
+			/*
+			 * If the page isn't too big, we are evicting it because
+			 * it had a chain of deleted entries that make traversal
+			 * expensive.
+			 */
+			WT_STAT_FAST_CONN_INCR(
+			    session, cache_eviction_force_delete);
+	} else {
 		WT_STAT_FAST_CONN_INCR(session, cache_eviction_force_fail);
-		if (ret == EBUSY)
-			ret = 0;
 	}
 	(void)WT_ATOMIC_SUB4(btree->evict_busy, 1);
 
@@ -983,6 +933,17 @@ __wt_page_release(WT_SESSION_IMPL *session, WT_REF *ref, uint32_t flags)
 }
 
 /*
+ * __wt_page_release --
+ *	Release a reference to a page.
+ */
+static inline int
+__wt_page_release(WT_SESSION_IMPL *session, WT_REF *ref, uint32_t flags)
+{
+	WT_RET_BUSY_OK(__wt_page_release_busy(session, ref, flags));
+	return (0);
+}
+
+/*
  * __wt_page_swap_func --
  *	Swap one page's hazard pointer for another one when hazard pointer
  * coupling up/down the tree.
diff --git a/src/third_party/wiredtiger/src/include/cache.h b/src/third_party/wiredtiger/src/include/cache.h
index 75219e5b413..deccd676e26 100644
--- a/src/third_party/wiredtiger/src/include/cache.h
+++ b/src/third_party/wiredtiger/src/include/cache.h
@@ -61,6 +61,8 @@ struct __wt_cache {
 	uint64_t bytes_dirty;		/* Bytes/pages currently dirty */
 	uint64_t pages_dirty;
 
+	uint64_t evict_max_page_size;	/* Largest page seen at eviction */
+
 	/*
 	 * Read information.
 	 */
diff --git a/src/third_party/wiredtiger/src/include/cache.i b/src/third_party/wiredtiger/src/include/cache.i
index b997781272a..ee969255241 100644
--- a/src/third_party/wiredtiger/src/include/cache.i
+++ b/src/third_party/wiredtiger/src/include/cache.i
@@ -7,6 +7,65 @@
  */
 
 /*
+ * __wt_cache_read_gen --
+ *      Get the current read generation number.
+ */
+static inline uint64_t
+__wt_cache_read_gen(WT_SESSION_IMPL *session)
+{
+	return (S2C(session)->cache->read_gen);
+}
+
+/*
+ * __wt_cache_read_gen_incr --
+ *      Increment the current read generation number.
+ */
+static inline void
+__wt_cache_read_gen_incr(WT_SESSION_IMPL *session)
+{
+	++S2C(session)->cache->read_gen;
+}
+
+/*
+ * __wt_cache_read_gen_set --
+ *      Get the read generation to store in a page.
+ */
+static inline uint64_t
+__wt_cache_read_gen_set(WT_SESSION_IMPL *session)
+{
+	/*
+	 * We return read-generations from the future (where "the future" is
+	 * measured by increments of the global read generation).  The reason
+	 * is because when acquiring a new hazard pointer for a page, we can
+	 * check its read generation, and if the read generation isn't less
+	 * than the current global generation, we don't bother updating the
+	 * page.  In other words, the goal is to avoid some number of updates
+	 * immediately after each update we have to make.
+	 */
+	return (__wt_cache_read_gen(session) + WT_READGEN_STEP);
+}
+
+/*
+ * __wt_cache_pages_inuse --
+ *	Return the number of pages in use.
+ */
+static inline uint64_t
+__wt_cache_pages_inuse(WT_CACHE *cache)
+{
+	return (cache->pages_inmem - cache->pages_evict);
+}
+
+/*
+ * __wt_cache_bytes_inuse --
+ *	Return the number of bytes in use.
+ */
+static inline uint64_t
+__wt_cache_bytes_inuse(WT_CACHE *cache)
+{
+	return (cache->bytes_inmem - cache->bytes_evict);
+}
+
+/*
  * __wt_eviction_check --
  *	Wake the eviction server if necessary.
  */
diff --git a/src/third_party/wiredtiger/src/include/cursor.h b/src/third_party/wiredtiger/src/include/cursor.h
index 0fc4b883a16..e46c1f7de1b 100644
--- a/src/third_party/wiredtiger/src/include/cursor.h
+++ b/src/third_party/wiredtiger/src/include/cursor.h
@@ -264,6 +264,8 @@ struct __wt_cursor_log {
 	WT_ITEM		*logrec;	/* Copy of record for cursor */
 	WT_ITEM		*opkey, *opvalue;	/* Op key/value copy */
 	const uint8_t	*stepp, *stepp_end;	/* Pointer within record */
+	uint8_t		*packed_key;	/* Packed key for 'raw' interface */
+	uint8_t		*packed_value;	/* Packed value for 'raw' interface */
 	uint32_t	step_count;	/* Intra-record count */
 	uint32_t	rectype;	/* Record type */
 	uint64_t	txnid;		/* Record txnid */
diff --git a/src/third_party/wiredtiger/src/include/cursor.i b/src/third_party/wiredtiger/src/include/cursor.i
index ae6aafdd638..8fa9790e096 100644
--- a/src/third_party/wiredtiger/src/include/cursor.i
+++ b/src/third_party/wiredtiger/src/include/cursor.i
@@ -176,11 +176,23 @@ static inline int
 __cursor_func_init(WT_CURSOR_BTREE *cbt, int reenter)
 {
 	WT_SESSION_IMPL *session;
+	WT_TXN *txn;
 
 	session = (WT_SESSION_IMPL *)cbt->iface.session;
+	txn = &session->txn;
 
 	if (reenter)
 		WT_RET(__curfile_leave(cbt));
+
+	/*
+	 * If there is no transaction active in this thread and we haven't
+	 * checked if the cache is full, do it now.  If we have to block for
+	 * eviction, this is the best time to do it.
+	 */
+	if (F_ISSET(txn, TXN_RUNNING) &&
+	    !F_ISSET(txn, TXN_HAS_ID) && !F_ISSET(txn, TXN_HAS_SNAPSHOT))
+		WT_RET(__wt_cache_full_check(session));
+
 	if (!F_ISSET(cbt, WT_CBT_ACTIVE))
 		WT_RET(__curfile_enter(cbt));
 	__wt_txn_cursor_op(session);
diff --git a/src/third_party/wiredtiger/src/include/extern.h b/src/third_party/wiredtiger/src/include/extern.h
index b80719de7c0..d8ed3f5cef1 100644
--- a/src/third_party/wiredtiger/src/include/extern.h
+++ b/src/third_party/wiredtiger/src/include/extern.h
@@ -432,6 +432,8 @@ extern int __wt_dlopen(WT_SESSION_IMPL *session, const char *path, WT_DLH **dlhp
 extern int __wt_dlsym(WT_SESSION_IMPL *session, WT_DLH *dlh, const char *name, int fail, void *sym_ret);
 extern int __wt_dlclose(WT_SESSION_IMPL *session, WT_DLH *dlh);
 extern int __wt_errno(void);
+extern const char *__wt_strerror(int error);
+extern int __wt_strerror_r(int error, char *buf, size_t buflen);
 extern int __wt_exist(WT_SESSION_IMPL *session, const char *filename, int *existp);
 extern void __wt_fallocate_config(WT_SESSION_IMPL *session, WT_FH *fh);
 extern int __wt_fallocate( WT_SESSION_IMPL *session, WT_FH *fh, wt_off_t offset, wt_off_t len);
diff --git a/src/third_party/wiredtiger/src/include/stat.h b/src/third_party/wiredtiger/src/include/stat.h
index 53a4ce3af4a..6efb9970065 100644
--- a/src/third_party/wiredtiger/src/include/stat.h
+++ b/src/third_party/wiredtiger/src/include/stat.h
@@ -164,9 +164,11 @@ struct __wt_connection_stats {
 	WT_STATS cache_eviction_dirty;
 	WT_STATS cache_eviction_fail;
 	WT_STATS cache_eviction_force;
+	WT_STATS cache_eviction_force_delete;
 	WT_STATS cache_eviction_force_fail;
 	WT_STATS cache_eviction_hazard;
 	WT_STATS cache_eviction_internal;
+	WT_STATS cache_eviction_maximum_page_size;
 	WT_STATS cache_eviction_queue_empty;
 	WT_STATS cache_eviction_queue_not_empty;
 	WT_STATS cache_eviction_server_evicting;
diff --git a/src/third_party/wiredtiger/src/include/txn.h b/src/third_party/wiredtiger/src/include/txn.h
index 36cb10c30d0..8380e55effb 100644
--- a/src/third_party/wiredtiger/src/include/txn.h
+++ b/src/third_party/wiredtiger/src/include/txn.h
@@ -7,6 +7,7 @@
  */
 
 #define	WT_TXN_NONE	0		/* No txn running in a session. */
+#define	WT_TXN_FIRST	1		/* First transaction to run. */
 #define	WT_TXN_ABORTED	UINT64_MAX	/* Update rolled back, ignore. */
 
 /*
diff --git a/src/third_party/wiredtiger/src/include/txn.i b/src/third_party/wiredtiger/src/include/txn.i
index 745a8f75a99..656181790ed 100644
--- a/src/third_party/wiredtiger/src/include/txn.i
+++ b/src/third_party/wiredtiger/src/include/txn.i
@@ -227,6 +227,16 @@ __wt_txn_id_check(WT_SESSION_IMPL *session)
 	txn = &session->txn;
 
 	WT_ASSERT(session, F_ISSET(txn, TXN_RUNNING));
+
+	/*
+	 * If there is no transaction active in this thread and we haven't
+	 * checked if the cache is full, do it now.  If we have to block for
+	 * eviction, this is the best time to do it.
+	 */
+	if (F_ISSET(txn, TXN_RUNNING) &&
+	    !F_ISSET(txn, TXN_HAS_ID) && !F_ISSET(txn, TXN_HAS_SNAPSHOT))
+		WT_RET(__wt_cache_full_check(session));
+
 	if (!F_ISSET(txn, TXN_HAS_ID)) {
 		conn = S2C(session);
 		txn_global = &conn->txn_global;
diff --git a/src/third_party/wiredtiger/src/include/wiredtiger.in b/src/third_party/wiredtiger/src/include/wiredtiger.in
index ee9c58e4278..91eb41af4f3 100644
--- a/src/third_party/wiredtiger/src/include/wiredtiger.in
+++ b/src/third_party/wiredtiger/src/include/wiredtiger.in
@@ -525,18 +525,17 @@ struct __wt_cursor {
 
 #define	WT_CURSTD_APPEND	0x0001
 #define	WT_CURSTD_BULK		0x0002
-#define	WT_CURSTD_DATA_SOURCE	0x0004
-#define	WT_CURSTD_DUMP_HEX	0x0008
-#define	WT_CURSTD_DUMP_JSON	0x0010
-#define	WT_CURSTD_DUMP_PRINT	0x0020
-#define	WT_CURSTD_KEY_EXT	0x0040	/* Key points out of the tree. */
-#define	WT_CURSTD_KEY_INT	0x0080	/* Key points into the tree. */
+#define	WT_CURSTD_DUMP_HEX	0x0004
+#define	WT_CURSTD_DUMP_JSON	0x0008
+#define	WT_CURSTD_DUMP_PRINT	0x0010
+#define	WT_CURSTD_KEY_EXT	0x0020	/* Key points out of the tree. */
+#define	WT_CURSTD_KEY_INT	0x0040	/* Key points into the tree. */
 #define	WT_CURSTD_KEY_SET	(WT_CURSTD_KEY_EXT | WT_CURSTD_KEY_INT)
-#define	WT_CURSTD_OPEN		0x0100
-#define	WT_CURSTD_OVERWRITE	0x0200
-#define	WT_CURSTD_RAW		0x0400
-#define	WT_CURSTD_VALUE_EXT	0x0800	/* Value points out of the tree. */
-#define	WT_CURSTD_VALUE_INT	0x1000	/* Value points into the tree. */
+#define	WT_CURSTD_OPEN		0x0080
+#define	WT_CURSTD_OVERWRITE	0x0100
+#define	WT_CURSTD_RAW		0x0200
+#define	WT_CURSTD_VALUE_EXT	0x0400	/* Value points out of the tree. */
+#define	WT_CURSTD_VALUE_INT	0x0800	/* Value points into the tree. */
 #define	WT_CURSTD_VALUE_SET	(WT_CURSTD_VALUE_EXT | WT_CURSTD_VALUE_INT)
 	uint32_t flags;
 #endif
@@ -2020,15 +2019,26 @@ int wiredtiger_open(const char *home,
     WT_CONNECTION **connectionp);
 
 /*!
- * Return information about an error as a string; wiredtiger_strerror is a
- * superset of the ISO C99/POSIX 1003.1-2001 function strerror.
+ * Return information about a WiredTiger error as a string, not thread-safe.
  *
  * @snippet ex_all.c Display an error
  *
- * @param err a return value from a WiredTiger, C library or POSIX function
+ * @param error a return value from a WiredTiger call
  * @returns a string representation of the error
  */
-const char *wiredtiger_strerror(int err);
+const char *wiredtiger_strerror(int error);
+
+/*!
+ * Return information about a WiredTiger error as a string, thread-safe version.
+ *
+ * @snippet ex_all.c Display an error thread safe
+ *
+ * @param error a return value from a WiredTiger call
+ * @param buf a buffer of at least \c buflen bytes
+ * @param buflen the length of the buffer
+ * @returns zero for success, non-zero to indicate an error.
+ */
+int wiredtiger_strerror_r(int error, char *buf, size_t buflen);
 
 #if !defined(SWIG)
 /*!
@@ -3155,204 +3165,208 @@ extern int wiredtiger_extension_terminate(WT_CONNECTION *connection);
 #define	WT_STAT_CONN_CACHE_EVICTION_FAIL		1030
 /*! cache: pages evicted because they exceeded the in-memory maximum */
 #define	WT_STAT_CONN_CACHE_EVICTION_FORCE		1031
+/*! cache: pages evicted because they had chains of deleted items */
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_DELETE	1032
 /*! cache: failed eviction of pages that exceeded the in-memory maximum */
-#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL		1032
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL		1033
 /*! cache: hazard pointer blocked page eviction */
-#define	WT_STAT_CONN_CACHE_EVICTION_HAZARD		1033
+#define	WT_STAT_CONN_CACHE_EVICTION_HAZARD		1034
 /*! cache: internal pages evicted */
-#define	WT_STAT_CONN_CACHE_EVICTION_INTERNAL		1034
+#define	WT_STAT_CONN_CACHE_EVICTION_INTERNAL		1035
+/*! cache: maximum page size at eviction */
+#define	WT_STAT_CONN_CACHE_EVICTION_MAXIMUM_PAGE_SIZE	1036
 /*! cache: eviction server candidate queue empty when topping up */
-#define	WT_STAT_CONN_CACHE_EVICTION_QUEUE_EMPTY		1035
+#define	WT_STAT_CONN_CACHE_EVICTION_QUEUE_EMPTY		1037
 /*! cache: eviction server candidate queue not empty when topping up */
-#define	WT_STAT_CONN_CACHE_EVICTION_QUEUE_NOT_EMPTY	1036
+#define	WT_STAT_CONN_CACHE_EVICTION_QUEUE_NOT_EMPTY	1038
 /*! cache: eviction server evicting pages */
-#define	WT_STAT_CONN_CACHE_EVICTION_SERVER_EVICTING	1037
+#define	WT_STAT_CONN_CACHE_EVICTION_SERVER_EVICTING	1039
 /*! cache: eviction server populating queue, but not evicting pages */
-#define	WT_STAT_CONN_CACHE_EVICTION_SERVER_NOT_EVICTING	1038
+#define	WT_STAT_CONN_CACHE_EVICTION_SERVER_NOT_EVICTING	1040
 /*! cache: eviction server unable to reach eviction goal */
-#define	WT_STAT_CONN_CACHE_EVICTION_SLOW		1039
+#define	WT_STAT_CONN_CACHE_EVICTION_SLOW		1041
 /*! cache: pages split during eviction */
-#define	WT_STAT_CONN_CACHE_EVICTION_SPLIT		1040
+#define	WT_STAT_CONN_CACHE_EVICTION_SPLIT		1042
 /*! cache: pages walked for eviction */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALK		1041
+#define	WT_STAT_CONN_CACHE_EVICTION_WALK		1043
 /*! cache: in-memory page splits */
-#define	WT_STAT_CONN_CACHE_INMEM_SPLIT			1042
+#define	WT_STAT_CONN_CACHE_INMEM_SPLIT			1044
 /*! cache: tracked dirty pages in the cache */
-#define	WT_STAT_CONN_CACHE_PAGES_DIRTY			1043
+#define	WT_STAT_CONN_CACHE_PAGES_DIRTY			1045
 /*! cache: pages currently held in the cache */
-#define	WT_STAT_CONN_CACHE_PAGES_INUSE			1044
+#define	WT_STAT_CONN_CACHE_PAGES_INUSE			1046
 /*! cache: pages read into cache */
-#define	WT_STAT_CONN_CACHE_READ				1045
+#define	WT_STAT_CONN_CACHE_READ				1047
 /*! cache: pages written from cache */
-#define	WT_STAT_CONN_CACHE_WRITE			1046
+#define	WT_STAT_CONN_CACHE_WRITE			1048
 /*! connection: pthread mutex condition wait calls */
-#define	WT_STAT_CONN_COND_WAIT				1047
+#define	WT_STAT_CONN_COND_WAIT				1049
 /*! cursor: cursor create calls */
-#define	WT_STAT_CONN_CURSOR_CREATE			1048
+#define	WT_STAT_CONN_CURSOR_CREATE			1050
 /*! cursor: cursor insert calls */
-#define	WT_STAT_CONN_CURSOR_INSERT			1049
+#define	WT_STAT_CONN_CURSOR_INSERT			1051
 /*! cursor: cursor next calls */
-#define	WT_STAT_CONN_CURSOR_NEXT			1050
+#define	WT_STAT_CONN_CURSOR_NEXT			1052
 /*! cursor: cursor prev calls */
-#define	WT_STAT_CONN_CURSOR_PREV			1051
+#define	WT_STAT_CONN_CURSOR_PREV			1053
 /*! cursor: cursor remove calls */
-#define	WT_STAT_CONN_CURSOR_REMOVE			1052
+#define	WT_STAT_CONN_CURSOR_REMOVE			1054
 /*! cursor: cursor reset calls */
-#define	WT_STAT_CONN_CURSOR_RESET			1053
+#define	WT_STAT_CONN_CURSOR_RESET			1055
 /*! cursor: cursor search calls */
-#define	WT_STAT_CONN_CURSOR_SEARCH			1054
+#define	WT_STAT_CONN_CURSOR_SEARCH			1056
 /*! cursor: cursor search near calls */
-#define	WT_STAT_CONN_CURSOR_SEARCH_NEAR			1055
+#define	WT_STAT_CONN_CURSOR_SEARCH_NEAR			1057
 /*! cursor: cursor update calls */
-#define	WT_STAT_CONN_CURSOR_UPDATE			1056
+#define	WT_STAT_CONN_CURSOR_UPDATE			1058
 /*! data-handle: connection dhandles swept */
-#define	WT_STAT_CONN_DH_CONN_HANDLES			1057
+#define	WT_STAT_CONN_DH_CONN_HANDLES			1059
 /*! data-handle: connection candidate referenced */
-#define	WT_STAT_CONN_DH_CONN_REF			1058
+#define	WT_STAT_CONN_DH_CONN_REF			1060
 /*! data-handle: connection sweeps */
-#define	WT_STAT_CONN_DH_CONN_SWEEPS			1059
+#define	WT_STAT_CONN_DH_CONN_SWEEPS			1061
 /*! data-handle: connection time-of-death sets */
-#define	WT_STAT_CONN_DH_CONN_TOD			1060
+#define	WT_STAT_CONN_DH_CONN_TOD			1062
 /*! data-handle: session dhandles swept */
-#define	WT_STAT_CONN_DH_SESSION_HANDLES			1061
+#define	WT_STAT_CONN_DH_SESSION_HANDLES			1063
 /*! data-handle: session sweep attempts */
-#define	WT_STAT_CONN_DH_SESSION_SWEEPS			1062
+#define	WT_STAT_CONN_DH_SESSION_SWEEPS			1064
 /*! connection: files currently open */
-#define	WT_STAT_CONN_FILE_OPEN				1063
+#define	WT_STAT_CONN_FILE_OPEN				1065
 /*! log: log buffer size increases */
-#define	WT_STAT_CONN_LOG_BUFFER_GROW			1064
+#define	WT_STAT_CONN_LOG_BUFFER_GROW			1066
 /*! log: total log buffer size */
-#define	WT_STAT_CONN_LOG_BUFFER_SIZE			1065
+#define	WT_STAT_CONN_LOG_BUFFER_SIZE			1067
 /*! log: log bytes of payload data */
-#define	WT_STAT_CONN_LOG_BYTES_PAYLOAD			1066
+#define	WT_STAT_CONN_LOG_BYTES_PAYLOAD			1068
 /*! log: log bytes written */
-#define	WT_STAT_CONN_LOG_BYTES_WRITTEN			1067
+#define	WT_STAT_CONN_LOG_BYTES_WRITTEN			1069
 /*! log: yields waiting for previous log file close */
-#define	WT_STAT_CONN_LOG_CLOSE_YIELDS			1068
+#define	WT_STAT_CONN_LOG_CLOSE_YIELDS			1070
 /*! log: total size of compressed records */
-#define	WT_STAT_CONN_LOG_COMPRESS_LEN			1069
+#define	WT_STAT_CONN_LOG_COMPRESS_LEN			1071
 /*! log: total in-memory size of compressed records */
-#define	WT_STAT_CONN_LOG_COMPRESS_MEM			1070
+#define	WT_STAT_CONN_LOG_COMPRESS_MEM			1072
 /*! log: log records too small to compress */
-#define	WT_STAT_CONN_LOG_COMPRESS_SMALL			1071
+#define	WT_STAT_CONN_LOG_COMPRESS_SMALL			1073
 /*! log: log records not compressed */
-#define	WT_STAT_CONN_LOG_COMPRESS_WRITE_FAILS		1072
+#define	WT_STAT_CONN_LOG_COMPRESS_WRITE_FAILS		1074
 /*! log: log records compressed */
-#define	WT_STAT_CONN_LOG_COMPRESS_WRITES		1073
+#define	WT_STAT_CONN_LOG_COMPRESS_WRITES		1075
 /*! log: maximum log file size */
-#define	WT_STAT_CONN_LOG_MAX_FILESIZE			1074
+#define	WT_STAT_CONN_LOG_MAX_FILESIZE			1076
 /*! log: pre-allocated log files prepared */
-#define	WT_STAT_CONN_LOG_PREALLOC_FILES			1075
+#define	WT_STAT_CONN_LOG_PREALLOC_FILES			1077
 /*! log: number of pre-allocated log files to create */
-#define	WT_STAT_CONN_LOG_PREALLOC_MAX			1076
+#define	WT_STAT_CONN_LOG_PREALLOC_MAX			1078
 /*! log: pre-allocated log files used */
-#define	WT_STAT_CONN_LOG_PREALLOC_USED			1077
+#define	WT_STAT_CONN_LOG_PREALLOC_USED			1079
 /*! log: log read operations */
-#define	WT_STAT_CONN_LOG_READS				1078
+#define	WT_STAT_CONN_LOG_READS				1080
 /*! log: records processed by log scan */
-#define	WT_STAT_CONN_LOG_SCAN_RECORDS			1079
+#define	WT_STAT_CONN_LOG_SCAN_RECORDS			1081
 /*! log: log scan records requiring two reads */
-#define	WT_STAT_CONN_LOG_SCAN_REREADS			1080
+#define	WT_STAT_CONN_LOG_SCAN_REREADS			1082
 /*! log: log scan operations */
-#define	WT_STAT_CONN_LOG_SCANS				1081
+#define	WT_STAT_CONN_LOG_SCANS				1083
 /*! log: consolidated slot closures */
-#define	WT_STAT_CONN_LOG_SLOT_CLOSES			1082
+#define	WT_STAT_CONN_LOG_SLOT_CLOSES			1084
 /*! log: logging bytes consolidated */
-#define	WT_STAT_CONN_LOG_SLOT_CONSOLIDATED		1083
+#define	WT_STAT_CONN_LOG_SLOT_CONSOLIDATED		1085
 /*! log: consolidated slot joins */
-#define	WT_STAT_CONN_LOG_SLOT_JOINS			1084
+#define	WT_STAT_CONN_LOG_SLOT_JOINS			1086
 /*! log: consolidated slot join races */
-#define	WT_STAT_CONN_LOG_SLOT_RACES			1085
+#define	WT_STAT_CONN_LOG_SLOT_RACES			1087
 /*! log: slots selected for switching that were unavailable */
-#define	WT_STAT_CONN_LOG_SLOT_SWITCH_FAILS		1086
+#define	WT_STAT_CONN_LOG_SLOT_SWITCH_FAILS		1088
 /*! log: record size exceeded maximum */
-#define	WT_STAT_CONN_LOG_SLOT_TOOBIG			1087
+#define	WT_STAT_CONN_LOG_SLOT_TOOBIG			1089
 /*! log: failed to find a slot large enough for record */
-#define	WT_STAT_CONN_LOG_SLOT_TOOSMALL			1088
+#define	WT_STAT_CONN_LOG_SLOT_TOOSMALL			1090
 /*! log: consolidated slot join transitions */
-#define	WT_STAT_CONN_LOG_SLOT_TRANSITIONS		1089
+#define	WT_STAT_CONN_LOG_SLOT_TRANSITIONS		1091
 /*! log: log sync operations */
-#define	WT_STAT_CONN_LOG_SYNC				1090
+#define	WT_STAT_CONN_LOG_SYNC				1092
 /*! log: log write operations */
-#define	WT_STAT_CONN_LOG_WRITES				1091
+#define	WT_STAT_CONN_LOG_WRITES				1093
 /*! LSM: sleep for LSM checkpoint throttle */
-#define	WT_STAT_CONN_LSM_CHECKPOINT_THROTTLE		1092
+#define	WT_STAT_CONN_LSM_CHECKPOINT_THROTTLE		1094
 /*! LSM: sleep for LSM merge throttle */
-#define	WT_STAT_CONN_LSM_MERGE_THROTTLE			1093
+#define	WT_STAT_CONN_LSM_MERGE_THROTTLE			1095
 /*! LSM: rows merged in an LSM tree */
-#define	WT_STAT_CONN_LSM_ROWS_MERGED			1094
+#define	WT_STAT_CONN_LSM_ROWS_MERGED			1096
 /*! LSM: application work units currently queued */
-#define	WT_STAT_CONN_LSM_WORK_QUEUE_APP			1095
+#define	WT_STAT_CONN_LSM_WORK_QUEUE_APP			1097
 /*! LSM: merge work units currently queued */
-#define	WT_STAT_CONN_LSM_WORK_QUEUE_MANAGER		1096
+#define	WT_STAT_CONN_LSM_WORK_QUEUE_MANAGER		1098
 /*! LSM: tree queue hit maximum */
-#define	WT_STAT_CONN_LSM_WORK_QUEUE_MAX			1097
+#define	WT_STAT_CONN_LSM_WORK_QUEUE_MAX			1099
 /*! LSM: switch work units currently queued */
-#define	WT_STAT_CONN_LSM_WORK_QUEUE_SWITCH		1098
+#define	WT_STAT_CONN_LSM_WORK_QUEUE_SWITCH		1100
 /*! LSM: tree maintenance operations scheduled */
-#define	WT_STAT_CONN_LSM_WORK_UNITS_CREATED		1099
+#define	WT_STAT_CONN_LSM_WORK_UNITS_CREATED		1101
 /*! LSM: tree maintenance operations discarded */
-#define	WT_STAT_CONN_LSM_WORK_UNITS_DISCARDED		1100
+#define	WT_STAT_CONN_LSM_WORK_UNITS_DISCARDED		1102
 /*! LSM: tree maintenance operations executed */
-#define	WT_STAT_CONN_LSM_WORK_UNITS_DONE		1101
+#define	WT_STAT_CONN_LSM_WORK_UNITS_DONE		1103
 /*! connection: memory allocations */
-#define	WT_STAT_CONN_MEMORY_ALLOCATION			1102
+#define	WT_STAT_CONN_MEMORY_ALLOCATION			1104
 /*! connection: memory frees */
-#define	WT_STAT_CONN_MEMORY_FREE			1103
+#define	WT_STAT_CONN_MEMORY_FREE			1105
 /*! connection: memory re-allocations */
-#define	WT_STAT_CONN_MEMORY_GROW			1104
+#define	WT_STAT_CONN_MEMORY_GROW			1106
 /*! thread-yield: page acquire busy blocked */
-#define	WT_STAT_CONN_PAGE_BUSY_BLOCKED			1105
+#define	WT_STAT_CONN_PAGE_BUSY_BLOCKED			1107
 /*! thread-yield: page acquire eviction blocked */
-#define	WT_STAT_CONN_PAGE_FORCIBLE_EVICT_BLOCKED	1106
+#define	WT_STAT_CONN_PAGE_FORCIBLE_EVICT_BLOCKED	1108
 /*! thread-yield: page acquire locked blocked */
-#define	WT_STAT_CONN_PAGE_LOCKED_BLOCKED		1107
+#define	WT_STAT_CONN_PAGE_LOCKED_BLOCKED		1109
 /*! thread-yield: page acquire read blocked */
-#define	WT_STAT_CONN_PAGE_READ_BLOCKED			1108
+#define	WT_STAT_CONN_PAGE_READ_BLOCKED			1110
 /*! thread-yield: page acquire time sleeping (usecs) */
-#define	WT_STAT_CONN_PAGE_SLEEP				1109
+#define	WT_STAT_CONN_PAGE_SLEEP				1111
 /*! connection: total read I/Os */
-#define	WT_STAT_CONN_READ_IO				1110
+#define	WT_STAT_CONN_READ_IO				1112
 /*! reconciliation: page reconciliation calls */
-#define	WT_STAT_CONN_REC_PAGES				1111
+#define	WT_STAT_CONN_REC_PAGES				1113
 /*! reconciliation: page reconciliation calls for eviction */
-#define	WT_STAT_CONN_REC_PAGES_EVICTION			1112
+#define	WT_STAT_CONN_REC_PAGES_EVICTION			1114
 /*! reconciliation: split bytes currently awaiting free */
-#define	WT_STAT_CONN_REC_SPLIT_STASHED_BYTES		1113
+#define	WT_STAT_CONN_REC_SPLIT_STASHED_BYTES		1115
 /*! reconciliation: split objects currently awaiting free */
-#define	WT_STAT_CONN_REC_SPLIT_STASHED_OBJECTS		1114
+#define	WT_STAT_CONN_REC_SPLIT_STASHED_OBJECTS		1116
 /*! connection: pthread mutex shared lock read-lock calls */
-#define	WT_STAT_CONN_RWLOCK_READ			1115
+#define	WT_STAT_CONN_RWLOCK_READ			1117
 /*! connection: pthread mutex shared lock write-lock calls */
-#define	WT_STAT_CONN_RWLOCK_WRITE			1116
+#define	WT_STAT_CONN_RWLOCK_WRITE			1118
 /*! session: open cursor count */
-#define	WT_STAT_CONN_SESSION_CURSOR_OPEN		1117
+#define	WT_STAT_CONN_SESSION_CURSOR_OPEN		1119
 /*! session: open session count */
-#define	WT_STAT_CONN_SESSION_OPEN			1118
+#define	WT_STAT_CONN_SESSION_OPEN			1120
 /*! transaction: transaction begins */
-#define	WT_STAT_CONN_TXN_BEGIN				1119
+#define	WT_STAT_CONN_TXN_BEGIN				1121
 /*! transaction: transaction checkpoints */
-#define	WT_STAT_CONN_TXN_CHECKPOINT			1120
+#define	WT_STAT_CONN_TXN_CHECKPOINT			1122
 /*! transaction: transaction checkpoint currently running */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_RUNNING		1121
+#define	WT_STAT_CONN_TXN_CHECKPOINT_RUNNING		1123
 /*! transaction: transaction checkpoint max time (msecs) */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_MAX		1122
+#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_MAX		1124
 /*! transaction: transaction checkpoint min time (msecs) */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_MIN		1123
+#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_MIN		1125
 /*! transaction: transaction checkpoint most recent time (msecs) */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_RECENT		1124
+#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_RECENT		1126
 /*! transaction: transaction checkpoint total time (msecs) */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_TOTAL		1125
+#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_TOTAL		1127
 /*! transaction: transactions committed */
-#define	WT_STAT_CONN_TXN_COMMIT				1126
+#define	WT_STAT_CONN_TXN_COMMIT				1128
 /*! transaction: transaction failures due to cache overflow */
-#define	WT_STAT_CONN_TXN_FAIL_CACHE			1127
+#define	WT_STAT_CONN_TXN_FAIL_CACHE			1129
 /*! transaction: transaction range of IDs currently pinned */
-#define	WT_STAT_CONN_TXN_PINNED_RANGE			1128
+#define	WT_STAT_CONN_TXN_PINNED_RANGE			1130
 /*! transaction: transactions rolled back */
-#define	WT_STAT_CONN_TXN_ROLLBACK			1129
+#define	WT_STAT_CONN_TXN_ROLLBACK			1131
 /*! connection: total write I/Os */
-#define	WT_STAT_CONN_WRITE_IO				1130
+#define	WT_STAT_CONN_WRITE_IO				1132
 
 /*!
  * @}
diff --git a/src/third_party/wiredtiger/src/include/wt_internal.h b/src/third_party/wiredtiger/src/include/wt_internal.h
index 138b64a6e27..1b3a9b62626 100644
--- a/src/third_party/wiredtiger/src/include/wt_internal.h
+++ b/src/third_party/wiredtiger/src/include/wt_internal.h
@@ -322,13 +322,13 @@ struct __wt_update;
 #include "misc.i"
 #include "intpack.i"			/* required by cell.i, packing.i */
 #include "packing.i"
+#include "cache.i"			/* required by txn.i */
 #include "cell.i"			/* required by btree.i */
 
 #include "mutex.i"			/* required by btree.i */
 #include "txn.i"			/* required by btree.i */
 
 #include "btree.i"			/* required by cursor.i */
-#include "cache.i"			/* required by cursor.i */
 #include "cursor.i"
 
 #include "bitstring.i"
diff --git a/src/third_party/wiredtiger/src/log/log.c b/src/third_party/wiredtiger/src/log/log.c
index a3abb336f3d..944e748a6a8 100644
--- a/src/third_party/wiredtiger/src/log/log.c
+++ b/src/third_party/wiredtiger/src/log/log.c
@@ -957,10 +957,14 @@ __log_release(WT_SESSION_IMPL *session, WT_LOGSLOT *slot)
 		    &slot->slot_buf, slot->slot_buf.memsize * 2));
 	}
 	/*
-	 * If we have a file to close, close it now.
+	 * If we have a file to close, close it now.  First fsync so
+	 * that a later sync will be assured all earlier transactions
+	 * in earlier log files are also on disk.
 	 */
-	if (close_fh)
+	if (close_fh) {
+		WT_ERR(__wt_fsync(session, close_fh));
 		WT_ERR(__wt_close(session, close_fh));
+	}
 
 err:	if (locked)
 		__wt_spin_unlock(session, &log->log_sync_lock);
diff --git a/src/third_party/wiredtiger/src/lsm/lsm_cursor.c b/src/third_party/wiredtiger/src/lsm/lsm_cursor.c
index 2dfaea1ec3a..0d44b16d85c 100644
--- a/src/third_party/wiredtiger/src/lsm/lsm_cursor.c
+++ b/src/third_party/wiredtiger/src/lsm/lsm_cursor.c
@@ -171,8 +171,6 @@ __clsm_enter(WT_CURSOR_LSM *clsm, int reset, int update)
 		    lsm_tree->nchunks != 0)
 			goto open;
 
-		WT_RET(__wt_cache_full_check(session));
-
 		if (clsm->dsk_gen != lsm_tree->dsk_gen &&
 		    lsm_tree->nchunks != 0)
 			goto open;
@@ -1484,11 +1482,8 @@ __wt_clsm_open(WT_SESSION_IMPL *session,
 	WT_ERR(__wt_cursor_init(cursor, cursor->uri, owner, cfg, cursorp));
 
 	if (0) {
-err:		__wt_lsm_tree_release(session, lsm_tree);
-		if (clsm != NULL) {
-			clsm->lsm_tree = NULL;
+err:		if (clsm != NULL)
 			WT_TRET(__clsm_close(cursor));
-		}
 	}
 
 	return (ret);
diff --git a/src/third_party/wiredtiger/src/os_posix/os_errno.c b/src/third_party/wiredtiger/src/os_posix/os_errno.c
index ed3451a9c1c..a58f13583ce 100644
--- a/src/third_party/wiredtiger/src/os_posix/os_errno.c
+++ b/src/third_party/wiredtiger/src/os_posix/os_errno.c
@@ -21,3 +21,49 @@ __wt_errno(void)
 	 */
 	return (errno == 0 ? WT_ERROR : errno);
 }
+
+/*
+ * __wt_strerror --
+ *	POSIX implementation of wiredtiger_strerror.
+ */
+const char *
+__wt_strerror(int error)
+{
+	const char *p;
+
+	/*
+	 * POSIX errors are non-negative integers; check for 0 explicitly
+	 * in-case the underlying strerror doesn't handle 0, some don't.
+	 */
+	if (error == 0)
+		return ("Successful return: 0");
+	if (error > 0 && (p = strerror(error)) != NULL)
+		return (p);
+	return (NULL);
+}
+
+/*
+ * __wt_strerror_r --
+ *	POSIX implementation of wiredtiger_strerror_r.
+ */
+int
+__wt_strerror_r(int error, char *buf, size_t buflen)
+{
+	const char *p;
+
+	/* Require at least 2 bytes, printable character and trailing nul. */
+	if (buflen < 2)
+		return (ENOMEM);
+
+	/*
+	 * Check for POSIX errors then fallback to something generic.  Copy the
+	 * string into the user's buffer, return success if anything printed.
+	 */
+	p = __wt_strerror(error);
+	if (p != NULL && snprintf(buf, buflen, "%s", p) > 0)
+		return (0);
+
+	/* Fallback to a generic message, then guess it's a memory problem. */
+	return (
+	    snprintf(buf, buflen, "error return: %d", error) > 0 ? 0 : ENOMEM);
+}
diff --git a/src/third_party/wiredtiger/src/os_win/os_errno.c b/src/third_party/wiredtiger/src/os_win/os_errno.c
index e321912d829..00ee638fbe3 100644
--- a/src/third_party/wiredtiger/src/os_win/os_errno.c
+++ b/src/third_party/wiredtiger/src/os_win/os_errno.c
@@ -8,6 +8,34 @@
 
 #include "wt_internal.h"
 
+static const int windows_error_offset = -29000;
+
+/*
+ * __wt_map_error_to_windows_error --
+ *	Return a negative integer, an encoded Windows error
+ * Standard C errors are positive integers from 0 - ~200
+ * Windows errors are from 0 - 15999 according to the documentation
+ */
+static DWORD
+__wt_map_error_to_windows_error(int error) {
+	/* Ensure we do not exceed the error range
+	   Also validate he do not get any COM errors
+	   (which are negative integers)
+	*/
+	WT_ASSERT(NULL, error > 0 && error > -(windows_error_offset));
+
+	return (error + -(windows_error_offset));
+}
+
+/*
+ * __wt_map_error_to_windows_error --
+ *	Return a positive integer, a decoded Windows error
+ */
+static int
+__wt_map_windows_error_to_error(DWORD winerr) {
+	return (winerr + windows_error_offset);
+}
+
 /*
  * __wt_errno --
  *	Return errno, or WT_ERROR if errno not set.
@@ -24,5 +52,73 @@ __wt_errno(void)
 	/* GetLastError should only be called if we hit an actual error */
 	WT_ASSERT(NULL, err != ERROR_SUCCESS);
 
-	return (err == ERROR_SUCCESS ? WT_ERROR : err);
+	return (err == ERROR_SUCCESS ?
+	    WT_ERROR : __wt_map_windows_error_to_error(err));
+}
+
+/*
+ * __wt_strerror --
+ *	Windows implementation of wiredtiger_strerror.
+ */
+const char *
+__wt_strerror(int error)
+{
+	const char *p;
+
+	/*
+	 * POSIX errors are non-negative integers; check for 0 explicitly
+	 * in-case the underlying strerror doesn't handle 0, some don't.
+	 */
+	if (error == 0)
+		return ("Successful return: 0");
+	if (error > 0 && (p = strerror(error)) != NULL)
+		return (p);
+	return (NULL);
+}
+
+/*
+ * __wt_strerror_r --
+ *	Windows implementation of wiredtiger_strerror_r.
+ */
+int
+__wt_strerror_r(int error, char *buf, size_t buflen)
+{
+	DWORD lasterror;
+	const char *p;
+
+	/* Require at least 2 bytes, printable character and trailing nul. */
+	if (buflen < 2)
+		return (ENOMEM);
+
+	/*
+	 * Check for POSIX errors, Windows errors, then fallback to something
+	 * generic.  Copy the string into the user's buffer, return success if
+	 * anything printed.
+	 */
+	p = __wt_strerror(error);
+	if (p != NULL && snprintf(buf, buflen, "%s", p) > 0)
+		return (0);
+
+	if (error < 0) {
+		error = __wt_map_error_to_windows_error(error);
+
+		lasterror = FormatMessageA(
+			FORMAT_MESSAGE_FROM_SYSTEM |
+			    FORMAT_MESSAGE_IGNORE_INSERTS,
+			NULL,
+			error,
+			0, /* let system choose the correct LANGID */
+			buf,
+			buflen,
+			NULL);
+
+		if (lasterror != 0)
+			return (0);
+
+		/* Fall through to the fallback error code */
+	}
+
+	/* Fallback to a generic message, then guess it's a memory problem. */
+	return (
+	    snprintf(buf, buflen, "error return: %d", error) > 0 ? 0 : ENOMEM);
 }
diff --git a/src/third_party/wiredtiger/src/os_win/os_ftruncate.c b/src/third_party/wiredtiger/src/os_win/os_ftruncate.c
index e80308536f1..d9b43e4596f 100644
--- a/src/third_party/wiredtiger/src/os_win/os_ftruncate.c
+++ b/src/third_party/wiredtiger/src/os_win/os_ftruncate.c
@@ -17,7 +17,6 @@ __wt_ftruncate(WT_SESSION_IMPL *session, WT_FH *fh, wt_off_t len)
 {
 	WT_DECL_RET;
 	LARGE_INTEGER largeint;
-	uint32_t lasterror;
 
 	largeint.QuadPart = len;
 
@@ -32,10 +31,8 @@ __wt_ftruncate(WT_SESSION_IMPL *session, WT_FH *fh, wt_off_t len)
 		return (0);
 	}
 
-	lasterror = GetLastError();
-
-	if (lasterror = ERROR_USER_MAPPED_FILE)
+	if (GetLastError() == ERROR_USER_MAPPED_FILE)
 		return (EBUSY);
 
-	WT_RET_MSG(session, lasterror, "%s SetEndOfFile error", fh->name);
+	WT_RET_MSG(session, __wt_errno(), "%s SetEndOfFile error", fh->name);
 }
diff --git a/src/third_party/wiredtiger/src/os_win/os_mtx_cond.c b/src/third_party/wiredtiger/src/os_win/os_mtx_cond.c
index 71ea8ed49a2..36de49d1aae 100644
--- a/src/third_party/wiredtiger/src/os_win/os_mtx_cond.c
+++ b/src/third_party/wiredtiger/src/os_win/os_mtx_cond.c
@@ -45,7 +45,6 @@ __wt_cond_wait(WT_SESSION_IMPL *session, WT_CONDVAR *cond, long usecs)
 {
 	WT_DECL_RET;
 	int locked;
-	int lasterror;
 	int milliseconds;
 	locked = 0;
 	WT_ASSERT(session, usecs >= 0);
@@ -82,8 +81,7 @@ __wt_cond_wait(WT_SESSION_IMPL *session, WT_CONDVAR *cond, long usecs)
 		    &cond->cond, &cond->mtx, INFINITE);
 
 	if (ret == 0) {
-		lasterror = GetLastError();
-		if (lasterror == ERROR_TIMEOUT) {
+		if (GetLastError() == ERROR_TIMEOUT) {
 			ret = 1;
 		}
 	}
diff --git a/src/third_party/wiredtiger/src/os_win/os_rename.c b/src/third_party/wiredtiger/src/os_win/os_rename.c
index 8c2784457c4..a0f33843218 100644
--- a/src/third_party/wiredtiger/src/os_win/os_rename.c
+++ b/src/third_party/wiredtiger/src/os_win/os_rename.c
@@ -33,13 +33,13 @@ __wt_rename(WT_SESSION_IMPL *session, const char *from, const char *to)
 	 */
 	if ((ret = GetFileAttributesA(to_path)) != INVALID_FILE_ATTRIBUTES) {
 		if ((ret = DeleteFileA(to_path)) == FALSE) {
-			lasterror = GetLastError();
+			lasterror = __wt_errno();
 			goto err;
 		}
 	}
 
 	if ((MoveFileA(from_path, to_path)) == FALSE)
-		lasterror = GetLastError();
+		lasterror = __wt_errno();
 
 err:
 	__wt_free(session, from_path);
diff --git a/src/third_party/wiredtiger/src/schema/schema_open.c b/src/third_party/wiredtiger/src/schema/schema_open.c
index 81447b173ae..d613ced00aa 100644
--- a/src/third_party/wiredtiger/src/schema/schema_open.c
+++ b/src/third_party/wiredtiger/src/schema/schema_open.c
@@ -327,6 +327,13 @@ __wt_schema_open_index(WT_SESSION_IMPL *session,
 
 			table->indices[i] = idx;
 			idx = NULL;
+
+			/*
+			 * If the slot is bigger than anything else we've seen,
+			 * bump the number of indices.
+			 */
+			if (i >= table->nindices)
+				table->nindices = i + 1;
 		}
 
 		/* If we were looking for a single index, we're done. */
diff --git a/src/third_party/wiredtiger/src/session/session_api.c b/src/third_party/wiredtiger/src/session/session_api.c
index 3ab5e0acab1..8ee143133ae 100644
--- a/src/third_party/wiredtiger/src/session/session_api.c
+++ b/src/third_party/wiredtiger/src/session/session_api.c
@@ -736,13 +736,6 @@ __session_begin_transaction(WT_SESSION *wt_session, const char *config)
 	if (F_ISSET(&session->txn, TXN_RUNNING))
 		WT_ERR_MSG(session, EINVAL, "Transaction already running");
 
-	/*
-	 * There is no transaction active in this thread; check if the cache is
-	 * full, if we have to block for eviction, this is the best time to do
-	 * it.
-	 */
-	WT_ERR(__wt_cache_full_check(session));
-
 	ret = __wt_txn_begin(session, cfg);
 
 err:	API_END_RET(session, ret);
diff --git a/src/third_party/wiredtiger/src/support/stat.c b/src/third_party/wiredtiger/src/support/stat.c
index c93168cd9a1..223d62d0559 100644
--- a/src/third_party/wiredtiger/src/support/stat.c
+++ b/src/third_party/wiredtiger/src/support/stat.c
@@ -367,6 +367,8 @@ __wt_stat_init_connection_stats(WT_CONNECTION_STATS *stats)
 	stats->cache_inmem_split.desc = "cache: in-memory page splits";
 	stats->cache_eviction_internal.desc = "cache: internal pages evicted";
 	stats->cache_bytes_max.desc = "cache: maximum bytes configured";
+	stats->cache_eviction_maximum_page_size.desc =
+	    "cache: maximum page size at eviction";
 	stats->cache_eviction_dirty.desc = "cache: modified pages evicted";
 	stats->cache_eviction_deepen.desc =
 	    "cache: page split during eviction deepened the tree";
@@ -374,6 +376,8 @@ __wt_stat_init_connection_stats(WT_CONNECTION_STATS *stats)
 	    "cache: pages currently held in the cache";
 	stats->cache_eviction_force.desc =
 	    "cache: pages evicted because they exceeded the in-memory maximum";
+	stats->cache_eviction_force_delete.desc =
+	    "cache: pages evicted because they had chains of deleted items";
 	stats->cache_eviction_app.desc =
 	    "cache: pages evicted by application threads";
 	stats->cache_read.desc = "cache: pages read into cache";
@@ -548,9 +552,11 @@ __wt_stat_refresh_connection_stats(void *stats_arg)
 	stats->cache_eviction_hazard.v = 0;
 	stats->cache_inmem_split.v = 0;
 	stats->cache_eviction_internal.v = 0;
+	stats->cache_eviction_maximum_page_size.v = 0;
 	stats->cache_eviction_dirty.v = 0;
 	stats->cache_eviction_deepen.v = 0;
 	stats->cache_eviction_force.v = 0;
+	stats->cache_eviction_force_delete.v = 0;
 	stats->cache_eviction_app.v = 0;
 	stats->cache_read.v = 0;
 	stats->cache_eviction_fail.v = 0;
diff --git a/src/third_party/wiredtiger/src/txn/txn.c b/src/third_party/wiredtiger/src/txn/txn.c
index cd130002c81..5b8f11a88a5 100644
--- a/src/third_party/wiredtiger/src/txn/txn.c
+++ b/src/third_party/wiredtiger/src/txn/txn.c
@@ -361,8 +361,15 @@ __wt_txn_commit(WT_SESSION_IMPL *session, const char *cfg[])
 	/* If we are logging, write a commit log record. */
 	if (ret == 0 && txn->mod_count > 0 &&
 	    FLD_ISSET(S2C(session)->log_flags, WT_CONN_LOG_ENABLED) &&
-	    !F_ISSET(session, WT_SESSION_NO_LOGGING))
+	    !F_ISSET(session, WT_SESSION_NO_LOGGING)) {
+		/*
+		 * We are about to block on I/O writing the log.
+		 * Release our snapshot in case it is keeping data pinned.
+		 * This is particularly important for checkpoints.
+		 */
+		__wt_txn_release_snapshot(session);
 		ret = __wt_txn_log_commit(session, cfg);
+	}
 
 	/*
 	 * If anything went wrong, roll back.
@@ -531,9 +538,8 @@ __wt_txn_global_init(WT_SESSION_IMPL *session, const char *cfg[])
 	conn = S2C(session);
 
 	txn_global = &conn->txn_global;
-	txn_global->current = 1;
-	txn_global->oldest_id = 1;
-	txn_global->last_running = 1;
+	txn_global->current = txn_global->last_running =
+	    txn_global->oldest_id = WT_TXN_FIRST;
 
 	WT_RET(__wt_calloc_def(
 	    session, conn->session_size, &txn_global->states));
diff --git a/src/third_party/wiredtiger/src/txn/txn_log.c b/src/third_party/wiredtiger/src/txn/txn_log.c
index f66bd7e09c8..f706efa8a70 100644
--- a/src/third_party/wiredtiger/src/txn/txn_log.c
+++ b/src/third_party/wiredtiger/src/txn/txn_log.c
@@ -270,6 +270,7 @@ __wt_txn_checkpoint_log(
 {
 	WT_DECL_ITEM(logrec);
 	WT_DECL_RET;
+	WT_ITEM *ckpt_snapshot, empty;
 	WT_LSN *ckpt_lsn;
 	WT_TXN *txn;
 	uint8_t *end, *p;
@@ -319,19 +320,22 @@ __wt_txn_checkpoint_log(
 		 */
 		if (!txn->full_ckpt) {
 			txn->ckpt_nsnapshot = 0;
+			WT_CLEAR(empty);
+			ckpt_snapshot = &empty;
 			*ckpt_lsn = S2C(session)->log->alloc_lsn;
-		}
+		} else
+			ckpt_snapshot = txn->ckpt_snapshot;
 
 		/* Write the checkpoint log record. */
 		WT_ERR(__wt_struct_size(session, &recsize, fmt,
 		    rectype, ckpt_lsn->file, ckpt_lsn->offset,
-		    txn->ckpt_nsnapshot, &txn->ckpt_snapshot));
+		    txn->ckpt_nsnapshot, ckpt_snapshot));
 		WT_ERR(__wt_logrec_alloc(session, recsize, &logrec));
 
 		WT_ERR(__wt_struct_pack(session,
 		    (uint8_t *)logrec->data + logrec->size, recsize, fmt,
 		    rectype, ckpt_lsn->file, ckpt_lsn->offset,
-		    txn->ckpt_nsnapshot, &txn->ckpt_snapshot));
+		    txn->ckpt_nsnapshot, ckpt_snapshot));
 		logrec->size += (uint32_t)recsize;
 		WT_ERR(__wt_log_write(session, logrec, lsnp, 0));
 
diff --git a/src/third_party/wiredtiger/tools/stat_data.py b/src/third_party/wiredtiger/tools/stat_data.py
index 7c00f6a70a8..89e06dbbf90 100644
--- a/src/third_party/wiredtiger/tools/stat_data.py
+++ b/src/third_party/wiredtiger/tools/stat_data.py
@@ -4,6 +4,7 @@ no_scale_per_second_list = [
     'async: maximum work queue length',
     'cache: bytes currently in the cache',
     'cache: maximum bytes configured',
+    'cache: maximum page size at eviction',
     'cache: pages currently held in the cache',
     'cache: tracked dirty bytes in the cache',
     'cache: tracked dirty pages in the cache',