Import wiredtiger: cb16839cfbdf338af95bed43ca40979ae6e32f54 from branch mongodb-3.6

ref: af735d14a6..cb16839cfb
for: 3.5.6

WT-3249       Unit test test_readonly fails as it is unable to open WiredTiger.lock
WT-3250       Incorrect statistics incremented on Windows
WT-3254       test_reconfig02 uses incorrect configuration string
WT-3262       Schema operations shouldn't wait for cache
WT-3265       Verify hits assertion in eviction when transiting handle to exclusive mode
WT-3271       Fix a bug where eviction tuning could get stuck in a loop

10 files changed, 78 insertions, 73 deletions

diff --git a/src/third_party/wiredtiger/import.data b/src/third_party/wiredtiger/import.data
index ce73f711a8a..f4234f523ed 100644
--- a/src/third_party/wiredtiger/import.data
+++ b/src/third_party/wiredtiger/import.data
@@ -1,5 +1,5 @@
 {
-    "commit": "af735d14a603a6ef6256a6685f09ec13755a5024", 
+    "commit": "cb16839cfbdf338af95bed43ca40979ae6e32f54", 
     "github": "wiredtiger/wiredtiger.git", 
     "branch": "mongodb-3.6"
 }
diff --git a/src/third_party/wiredtiger/src/evict/evict_lru.c b/src/third_party/wiredtiger/src/evict/evict_lru.c
index 3ce35c60f2e..26bbf9f679b 100644
--- a/src/third_party/wiredtiger/src/evict/evict_lru.c
+++ b/src/third_party/wiredtiger/src/evict/evict_lru.c
@@ -934,9 +934,9 @@ __evict_tune_workers(WT_SESSION_IMPL *session)
 	WT_CACHE *cache;
 	WT_CONNECTION_IMPL *conn;
 	WT_DECL_RET;
-	uint64_t cur_threads, delta_msec, delta_pages, i, target_threads;
+	uint64_t delta_msec, delta_pages;
 	uint64_t pgs_evicted_cur, pgs_evicted_persec_cur, time_diff;
-	uint32_t thread_surplus;
+	int32_t cur_threads, i, target_threads, thread_surplus;
 
 	conn = S2C(session);
 	cache = conn->cache;
@@ -967,8 +967,10 @@ __evict_tune_workers(WT_SESSION_IMPL *session)
 		conn->evict_tune_workers_best = 0;
 
 		/* Reduce the number of eviction workers to the minimum */
-		thread_surplus = conn->evict_threads.current_threads -
-		    conn->evict_threads_min;
+		thread_surplus =
+		    (int32_t)conn->evict_threads.current_threads -
+		    (int32_t)conn->evict_threads_min;
+
 		for (i = 0; i < thread_surplus; i++) {
 			WT_ERR(__wt_thread_group_stop_one(
 			    session, &conn->evict_threads, false));
@@ -1026,18 +1028,18 @@ __evict_tune_workers(WT_SESSION_IMPL *session)
 	 * settle into a stable state.
 	 */
 	if (conn->evict_tune_num_points >= conn->evict_tune_datapts_needed) {
-		if ((conn->evict_tune_workers_best ==
-		    conn->evict_threads.current_threads) &&
-		    (conn->evict_threads.current_threads <
-		    conn->evict_threads_max)) {
+		if (conn->evict_tune_workers_best ==
+		    conn->evict_threads.current_threads &&
+		    conn->evict_threads.current_threads <
+		    conn->evict_threads_max) {
 			/*
 			 * Keep adding workers. We will check again
 			 * at the next check point.
 			 */
-			conn->evict_tune_datapts_needed +=
-			    WT_MIN(EVICT_TUNE_DATAPT_MIN,
-			    (conn->evict_threads_max
-			    - conn->evict_threads.current_threads) /
+			conn->evict_tune_datapts_needed += WT_MIN(
+			    EVICT_TUNE_DATAPT_MIN,
+			    (conn->evict_threads_max -
+			    conn->evict_threads.current_threads) /
 			    EVICT_TUNE_BATCH);
 		} else {
 			/*
@@ -1046,8 +1048,8 @@ __evict_tune_workers(WT_SESSION_IMPL *session)
 			 * settle into a stable state.
 			 */
 			thread_surplus =
-			    conn->evict_threads.current_threads -
-			    conn->evict_tune_workers_best;
+			    (int32_t)conn->evict_threads.current_threads -
+			    (int32_t)conn->evict_tune_workers_best;
 
 			for (i = 0; i < thread_surplus; i++) {
 				/*
@@ -1082,13 +1084,13 @@ __evict_tune_workers(WT_SESSION_IMPL *session)
 		    conn->evict_threads.current_threads) / EVICT_TUNE_BATCH);
 
 	if (F_ISSET(cache, WT_CACHE_EVICT_ALL)) {
-		cur_threads = conn->evict_threads.current_threads;
+		cur_threads = (int32_t)conn->evict_threads.current_threads;
 		target_threads = WT_MIN(cur_threads + EVICT_TUNE_BATCH,
-		    conn->evict_threads_max);
+		    (int32_t)conn->evict_threads_max);
 		/*
 		 * Start the new threads.
 		 */
-		for (i = 0; i < (target_threads - cur_threads); ++i) {
+		for (i = cur_threads; i < target_threads; ++i) {
 			/*
 			 * If we get an error, it should be because we were
 			 * unable to acquire the thread group lock.  Break out
diff --git a/src/third_party/wiredtiger/src/include/btree.i b/src/third_party/wiredtiger/src/include/btree.i
index a4d88d5fda1..1d6fcd6272c 100644
--- a/src/third_party/wiredtiger/src/include/btree.i
+++ b/src/third_party/wiredtiger/src/include/btree.i
@@ -1354,8 +1354,13 @@ __wt_page_can_evict(
 	 * the original parent page's index, because evicting an internal page
 	 * discards its WT_REF array, and a thread traversing the original
 	 * parent page index might see a freed WT_REF.
+	 *
+	 * One special case where we know this is safe is if the handle is
+	 * locked exclusive (e.g., when the whole tree is being evicted).  In
+	 * that case, no readers can be looking at an old index.
 	 */
-	if (WT_PAGE_IS_INTERNAL(page) && !__wt_split_obsolete(
+	if (!F_ISSET(session->dhandle, WT_DHANDLE_EXCLUSIVE) &&
+	    WT_PAGE_IS_INTERNAL(page) && !__wt_split_obsolete(
 	    session, page->pg_intl_split_gen))
 		return (false);
 
diff --git a/src/third_party/wiredtiger/src/include/cache.i b/src/third_party/wiredtiger/src/include/cache.i
index d71978ccf35..90dd1bcdda8 100644
--- a/src/third_party/wiredtiger/src/include/cache.i
+++ b/src/third_party/wiredtiger/src/include/cache.i
@@ -360,11 +360,13 @@ __wt_cache_eviction_check(WT_SESSION_IMPL *session, bool busy, bool *didworkp)
 
 	/*
 	 * LSM sets the no-cache-check flag when holding the LSM tree lock, in
-	 * that case, or when holding the schema or handle list locks (which
-	 * block eviction), we don't want to highjack the thread for eviction.
+	 * that case, or when holding the handle list, schema or table locks
+	 * (which can block checkpoints and eviction), don't block the thread
+	 * for eviction.
 	 */
 	if (F_ISSET(session, WT_SESSION_NO_EVICTION |
-	    WT_SESSION_LOCKED_HANDLE_LIST_WRITE | WT_SESSION_LOCKED_SCHEMA))
+	    WT_SESSION_LOCKED_HANDLE_LIST | WT_SESSION_LOCKED_SCHEMA |
+	    WT_SESSION_LOCKED_TABLE))
 		return (0);
 
 	/* In memory configurations don't block when the cache is full. */
@@ -372,11 +374,14 @@ __wt_cache_eviction_check(WT_SESSION_IMPL *session, bool busy, bool *didworkp)
 		return (0);
 
 	/*
-	 * Threads operating on cache-resident trees are ignored because they're
-	 * not contributing to the problem.
+	 * Threads operating on cache-resident trees are ignored because
+	 * they're not contributing to the problem.  We also don't block while
+	 * reading metadata because we're likely to be holding some other
+	 * resources that could block checkpoints or eviction.
 	 */
 	btree = S2BT_SAFE(session);
-	if (btree != NULL && F_ISSET(btree, WT_BTREE_IN_MEMORY))
+	if (btree != NULL && (F_ISSET(btree, WT_BTREE_IN_MEMORY) ||
+	    WT_IS_METADATA(session->dhandle)))
 		return (0);
 
 	/* Check if eviction is needed. */
diff --git a/src/third_party/wiredtiger/src/include/extern.h b/src/third_party/wiredtiger/src/include/extern.h
index c0a6087e9b1..55ba1bada7c 100644
--- a/src/third_party/wiredtiger/src/include/extern.h
+++ b/src/third_party/wiredtiger/src/include/extern.h
@@ -404,7 +404,7 @@ extern int __wt_logop_row_truncate_unpack( WT_SESSION_IMPL *session, const uint8
 extern int __wt_logop_row_truncate_print(WT_SESSION_IMPL *session, const uint8_t **pp, const uint8_t *end, uint32_t flags) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)) WT_GCC_FUNC_DECL_ATTRIBUTE((visibility("hidden")));
 extern int __wt_txn_op_printlog(WT_SESSION_IMPL *session, const uint8_t **pp, const uint8_t *end, uint32_t flags) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)) WT_GCC_FUNC_DECL_ATTRIBUTE((visibility("hidden")));
 extern void __wt_log_slot_activate(WT_SESSION_IMPL *session, WT_LOGSLOT *slot) WT_GCC_FUNC_DECL_ATTRIBUTE((visibility("hidden")));
-extern int __wt_log_slot_switch( WT_SESSION_IMPL *session, WT_MYSLOT *myslot, bool retry, bool forced) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)) WT_GCC_FUNC_DECL_ATTRIBUTE((visibility("hidden")));
+extern int __wt_log_slot_switch(WT_SESSION_IMPL *session, WT_MYSLOT *myslot, bool retry, bool forced, bool *did_work) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)) WT_GCC_FUNC_DECL_ATTRIBUTE((visibility("hidden")));
 extern int __wt_log_slot_init(WT_SESSION_IMPL *session) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)) WT_GCC_FUNC_DECL_ATTRIBUTE((visibility("hidden")));
 extern int __wt_log_slot_destroy(WT_SESSION_IMPL *session) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)) WT_GCC_FUNC_DECL_ATTRIBUTE((visibility("hidden")));
 extern int __wt_log_slot_join(WT_SESSION_IMPL *session, uint64_t mysize, uint32_t flags, WT_MYSLOT *myslot) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)) WT_GCC_FUNC_DECL_ATTRIBUTE((visibility("hidden")));
diff --git a/src/third_party/wiredtiger/src/include/mutex.h b/src/third_party/wiredtiger/src/include/mutex.h
index 06b8c4a3304..910eb7af5b9 100644
--- a/src/third_party/wiredtiger/src/include/mutex.h
+++ b/src/third_party/wiredtiger/src/include/mutex.h
@@ -62,31 +62,17 @@ union __wt_rwlock {			/* Read/write lock */
 #define	SPINLOCK_PTHREAD_MUTEX		2
 #define	SPINLOCK_PTHREAD_MUTEX_ADAPTIVE	3
 
-#if SPINLOCK_TYPE == SPINLOCK_GCC
-
 struct __wt_spinlock {
 	WT_CACHE_LINE_PAD_BEGIN
+#if SPINLOCK_TYPE == SPINLOCK_GCC
 	volatile int lock;
-
-	/*
-	 * We track acquisitions and time spent waiting for some locks. For
-	 * performance reasons and to make it possible to write generic code
-	 * that tracks statistics for different locks, we store the offset
-	 * of the statistics fields to be updated during lock acquisition.
-	 */
-	int16_t stat_count_off;		/* acquisitions offset */
-	int16_t stat_app_usecs_off;	/* waiting application threads offset */
-	int16_t stat_int_usecs_off;	/* waiting server threads offset */
-	WT_CACHE_LINE_PAD_END
-};
-
 #elif SPINLOCK_TYPE == SPINLOCK_PTHREAD_MUTEX ||\
 	SPINLOCK_TYPE == SPINLOCK_PTHREAD_MUTEX_ADAPTIVE ||\
 	SPINLOCK_TYPE == SPINLOCK_MSVC
-
-struct __wt_spinlock {
-	WT_CACHE_LINE_PAD_BEGIN
 	wt_mutex_t lock;
+#else
+#error Unknown spinlock type
+#endif
 
 	const char *name;		/* Mutex name */
 
@@ -103,9 +89,3 @@ struct __wt_spinlock {
 	int8_t initialized;		/* Lock initialized, for cleanup */
 	WT_CACHE_LINE_PAD_END
 };
-
-#else
-
-#error Unknown spinlock type
-
-#endif
diff --git a/src/third_party/wiredtiger/src/include/mutex.i b/src/third_party/wiredtiger/src/include/mutex.i
index 640706284c3..2d483972ed2 100644
--- a/src/third_party/wiredtiger/src/include/mutex.i
+++ b/src/third_party/wiredtiger/src/include/mutex.i
@@ -14,6 +14,18 @@
  * of instructions.
  */
 
+/*
+ * __spin_init_internal --
+ *      Initialize the WT portion of a spinlock.
+ */
+static inline void
+__spin_init_internal(WT_SPINLOCK *t, const char *name)
+{
+	t->name = name;
+	t->stat_count_off = t->stat_app_usecs_off = t->stat_int_usecs_off = -1;
+	t->initialized = 1;
+}
+
 #if SPINLOCK_TYPE == SPINLOCK_GCC
 
 /* Default to spinning 1000 times before yielding. */
@@ -29,10 +41,9 @@ static inline int
 __wt_spin_init(WT_SESSION_IMPL *session, WT_SPINLOCK *t, const char *name)
 {
 	WT_UNUSED(session);
-	WT_UNUSED(name);
 
 	t->lock = 0;
-	t->stat_count_off = t->stat_app_usecs_off = t->stat_int_usecs_off = -1;
+	__spin_init_internal(t, name);
 	return (0);
 }
 
@@ -110,10 +121,7 @@ __wt_spin_init(WT_SESSION_IMPL *session, WT_SPINLOCK *t, const char *name)
 #else
 	WT_RET(pthread_mutex_init(&t->lock, NULL));
 #endif
-
-	t->name = name;
-	t->stat_count_off = t->stat_app_usecs_off = t->stat_int_usecs_off = -1;
-	t->initialized = 1;
+	__spin_init_internal(t, name);
 
 	WT_UNUSED(session);
 	return (0);
@@ -195,8 +203,7 @@ __wt_spin_init(WT_SESSION_IMPL *session, WT_SPINLOCK *t, const char *name)
 		return (__wt_map_windows_error(windows_error));
 	}
 
-	t->name = name;
-	t->initialized = 1;
+	__spin_init_internal(t, name);
 	return (0);
 }
 
diff --git a/src/third_party/wiredtiger/src/log/log.c b/src/third_party/wiredtiger/src/log/log.c
index 5b24250fffc..803d3e8dfab 100644
--- a/src/third_party/wiredtiger/src/log/log.c
+++ b/src/third_party/wiredtiger/src/log/log.c
@@ -1919,7 +1919,6 @@ __wt_log_force_write(WT_SESSION_IMPL *session, bool retry, bool *did_work)
 {
 	WT_LOG *log;
 	WT_MYSLOT myslot;
-	uint32_t joined;
 
 	log = S2C(session)->log;
 	memset(&myslot, 0, sizeof(myslot));
@@ -1927,14 +1926,7 @@ __wt_log_force_write(WT_SESSION_IMPL *session, bool retry, bool *did_work)
 	if (did_work != NULL)
 		*did_work = true;
 	myslot.slot = log->active_slot;
-	joined = WT_LOG_SLOT_JOINED(log->active_slot->slot_state);
-	if (joined == 0) {
-		WT_STAT_CONN_INCR(session, log_force_write_skip);
-		if (did_work != NULL)
-			*did_work = false;
-		return (0);
-	}
-	return (__wt_log_slot_switch(session, &myslot, retry, true));
+	return (__wt_log_slot_switch(session, &myslot, retry, true, did_work));
 }
 
 /*
@@ -2146,7 +2138,7 @@ __log_write_internal(WT_SESSION_IMPL *session, WT_ITEM *record, WT_LSN *lsnp,
 	ret = 0;
 	if (myslot.end_offset >= WT_LOG_SLOT_BUF_MAX ||
 	    F_ISSET(&myslot, WT_MYSLOT_UNBUFFERED) || force)
-		ret = __wt_log_slot_switch(session, &myslot, true, false);
+		ret = __wt_log_slot_switch(session, &myslot, true, false, NULL);
 	if (ret == 0)
 		ret = __log_fill(session, &myslot, false, record, &lsn);
 	release_size = __wt_log_slot_release(
diff --git a/src/third_party/wiredtiger/src/log/log_slot.c b/src/third_party/wiredtiger/src/log/log_slot.c
index 512a84dbd13..97e317ce68c 100644
--- a/src/third_party/wiredtiger/src/log/log_slot.c
+++ b/src/third_party/wiredtiger/src/log/log_slot.c
@@ -286,12 +286,13 @@ __log_slot_new(WT_SESSION_IMPL *session)
  */
 static int
 __log_slot_switch_internal(
-    WT_SESSION_IMPL *session, WT_MYSLOT *myslot, bool forced)
+    WT_SESSION_IMPL *session, WT_MYSLOT *myslot, bool forced, bool *did_work)
 {
 	WT_DECL_RET;
 	WT_LOG *log;
 	WT_LOGSLOT *slot;
 	bool free_slot, release;
+	uint32_t joined;
 
 	log = S2C(session)->log;
 	release = false;
@@ -305,6 +306,18 @@ __log_slot_switch_internal(
 	 */
 	if (slot != log->active_slot)
 		return (0);
+	/*
+	 * If the current active slot is unused and this is a forced switch,
+	 * we're done.  If this is a non-forced switch we always switch
+	 * because the slot could be part of an unbuffered operation.
+	 */
+	joined = WT_LOG_SLOT_JOINED(slot->slot_state);
+	if (joined == 0 && forced) {
+		WT_STAT_CONN_INCR(session, log_force_write_skip);
+		if (did_work != NULL)
+			*did_work = false;
+		return (0);
+	}
 	WT_RET(WT_SESSION_CHECK_PANIC(session));
 
 	/*
@@ -352,8 +365,8 @@ __log_slot_switch_internal(
  *	Switch out the current slot and set up a new one.
  */
 int
-__wt_log_slot_switch(
-    WT_SESSION_IMPL *session, WT_MYSLOT *myslot, bool retry, bool forced)
+__wt_log_slot_switch(WT_SESSION_IMPL *session,
+    WT_MYSLOT *myslot, bool retry, bool forced, bool *did_work)
 {
 	WT_DECL_RET;
 	WT_LOG *log;
@@ -373,7 +386,8 @@ __wt_log_slot_switch(
 	 */
 	do {
 		WT_WITH_SLOT_LOCK(session, log,
-		    ret = __log_slot_switch_internal(session, myslot, forced));
+		    ret = __log_slot_switch_internal(
+		    session, myslot, forced, did_work));
 		if (ret == EBUSY) {
 			WT_STAT_CONN_INCR(session, log_slot_switch_busy);
 			__wt_yield();
diff --git a/src/third_party/wiredtiger/test/suite/test_reconfig02.py b/src/third_party/wiredtiger/test/suite/test_reconfig02.py
index 8054b2a6ab5..042d3bbe71f 100644
--- a/src/third_party/wiredtiger/test/suite/test_reconfig02.py
+++ b/src/third_party/wiredtiger/test/suite/test_reconfig02.py
@@ -62,7 +62,7 @@ class test_reconfig02(wttest.WiredTigerTestCase):
         self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
             lambda: self.conn.reconfigure("log=(path=foo)"), msg)
         self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
-            lambda: self.conn.reconfigure("log=(recovery=true)"), msg)
+            lambda: self.conn.reconfigure("log=(recover=true)"), msg)
 
     # Logging starts on, but prealloc is off.  Verify it is off.
     # Reconfigure it on and run again, making sure that log files