Merge 10.2 into bb-10.2-ext

22 files changed, 133 insertions, 618 deletions

diff --git a/storage/innobase/btr/btr0bulk.cc b/storage/innobase/btr/btr0bulk.cc
index 9ff3bc5f6d1..8a954f9d3c3 100644
--- a/storage/innobase/btr/btr0bulk.cc
+++ b/storage/innobase/btr/btr0bulk.cc
@@ -1,6 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 2014, 2016, Oracle and/or its affiliates. All Rights Reserved.
+Copyright (c) 2017, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -991,11 +992,7 @@ BtrBulk::finish(dberr_t	err)
 		ut_ad(err == DB_SUCCESS);
 	}
 
-#ifdef UNIV_DEBUG
-	dict_sync_check check(true);
-
-	ut_ad(!sync_check_iterate(check));
-#endif /* UNIV_DEBUG */
+	ut_ad(!sync_check_iterate(dict_sync_check()));
 
 	ut_ad(err != DB_SUCCESS || btr_validate_index(m_index, NULL, false));
 	return(err);
diff --git a/storage/innobase/buf/buf0flu.cc b/storage/innobase/buf/buf0flu.cc
index 05ab07229e3..791939f32dd 100644
--- a/storage/innobase/buf/buf0flu.cc
+++ b/storage/innobase/buf/buf0flu.cc
@@ -1870,15 +1870,8 @@ buf_flush_batch(
 					counts  */
 {
 	ut_ad(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST);
-
-#ifdef UNIV_DEBUG
-	{
-		dict_sync_check	check(true);
-
-		ut_ad(flush_type != BUF_FLUSH_LIST
-		      || !sync_check_iterate(check));
-	}
-#endif /* UNIV_DEBUG */
+	ut_ad(flush_type == BUF_FLUSH_LRU
+	      || !sync_check_iterate(dict_sync_check()));
 
 	buf_pool_mutex_enter(buf_pool);
 
diff --git a/storage/innobase/dict/dict0dict.cc b/storage/innobase/dict/dict0dict.cc
index 63507e0a2c9..df36a320616 100644
--- a/storage/innobase/dict/dict0dict.cc
+++ b/storage/innobase/dict/dict0dict.cc
@@ -6114,14 +6114,7 @@ dict_set_corrupted(
 	ut_ad(mutex_own(&dict_sys->mutex));
 	ut_ad(!dict_table_is_comp(dict_sys->sys_tables));
 	ut_ad(!dict_table_is_comp(dict_sys->sys_indexes));
-
-#ifdef UNIV_DEBUG
-	{
-		dict_sync_check	check(true);
-
-		ut_ad(!sync_check_iterate(check));
-	}
-#endif /* UNIV_DEBUG */
+	ut_ad(!sync_check_iterate(dict_sync_check()));
 
 	/* Mark the table as corrupted only if the clustered index
 	is corrupted */
diff --git a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
index b4e2983dbd3..b0a65fa2c13 100644
--- a/storage/innobase/handler/ha_innodb.cc
+++ b/storage/innobase/handler/ha_innodb.cc
@@ -1869,6 +1869,8 @@ void
 innobase_srv_conc_exit_innodb(
 	row_prebuilt_t*	prebuilt)
 {
+	ut_ad(!sync_check_iterate(sync_check()));
+
 #ifdef WITH_WSREP
 	if (wsrep_on(prebuilt->trx->mysql_thd) &&
 	    wsrep_thd_is_BF(prebuilt->trx->mysql_thd, FALSE)) {
@@ -1877,13 +1879,6 @@ innobase_srv_conc_exit_innodb(
 #endif /* WITH_WSREP */
 
 	trx_t*			trx = prebuilt->trx;
-#ifdef BTR_CUR_HASH_ADAPT
-# ifdef UNIV_DEBUG
-	btrsea_sync_check	check(trx->has_search_latch);
-
-	ut_ad(!sync_check_iterate(check));
-# endif /* UNIV_DEBUG */
-#endif /* BTR_CUR_HASH_ADAPT */
 
 	/* This is to avoid making an unnecessary function call. */
 	if (trx->declared_to_be_inside_innodb
@@ -1901,13 +1896,7 @@ innobase_srv_conc_force_exit_innodb(
 /*================================*/
 	trx_t*	trx)	/*!< in: transaction handle */
 {
-#ifdef BTR_CUR_HASH_ADAPT
-# ifdef UNIV_DEBUG
-	btrsea_sync_check	check(trx->has_search_latch);
-
-	ut_ad(!sync_check_iterate(check));
-# endif /* UNIV_DEBUG */
-#endif /* BTR_CUR_HASH_ADAPT */
+	ut_ad(!sync_check_iterate(sync_check()));
 
 	/* This is to avoid making an unnecessary function call. */
 	if (trx->declared_to_be_inside_innodb) {
@@ -1994,13 +1983,7 @@ const char*
 thd_innodb_tmpdir(
 	THD*	thd)
 {
-#ifdef BTR_CUR_HASH_ADAPT
-# ifdef UNIV_DEBUG
-	trx_t*	trx = thd_to_trx(thd);
-	btrsea_sync_check	check(trx->has_search_latch);
-	ut_ad(!sync_check_iterate(check));
-# endif /* UNIV_DEBUG */
-#endif /* BTR_CUR_HASH_ADAPT */
+	ut_ad(!sync_check_iterate(sync_check()));
 
 	const char*	tmp_dir = THDVAR(thd, tmpdir);
 
@@ -2036,28 +2019,6 @@ thd_to_trx_id(
 #endif /* WITH_WSREP */
 
 /********************************************************************//**
-Call this function when mysqld passes control to the client. That is to
-avoid deadlocks on the adaptive hash S-latch possibly held by thd. For more
-documentation, see handler.cc.
-@return 0 */
-inline
-int
-innobase_release_temporary_latches(
-/*===============================*/
-	handlerton*	hton,	/*!< in: handlerton */
-	THD*		thd)	/*!< in: MySQL thread */
-{
-	DBUG_ASSERT(hton == innodb_hton_ptr);
-
-	if (!srv_was_started) {
-	} else if (trx_t* trx __attribute__((unused))= thd_to_trx(thd)) {
-		trx_assert_no_search_latch(trx);
-	}
-
-	return(0);
-}
-
-/********************************************************************//**
 Increments innobase_active_counter and every INNOBASE_WAKE_INTERVALth
 time calls srv_active_wake_master_thread. This function should be used
 when a single database operation may introduce a small need for
@@ -3384,7 +3345,6 @@ innobase_query_caching_of_table_permitted(
 		return(false);
 	}
 
-	trx_assert_no_search_latch(trx);
 	innobase_srv_conc_force_exit_innodb(trx);
 
 	if (!thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)
@@ -3692,8 +3652,6 @@ ha_innobase::init_table_handle_for_HANDLER(void)
 	/* Initialize the m_prebuilt struct much like it would be inited in
 	external_lock */
 
-	trx_assert_no_search_latch(m_prebuilt->trx);
-
 	innobase_srv_conc_force_exit_innodb(m_prebuilt->trx);
 
 	/* If the transaction is not started yet, start it */
@@ -3913,9 +3871,6 @@ innobase_init(
 	innobase_hton->flags =
 		HTON_SUPPORTS_EXTENDED_KEYS | HTON_SUPPORTS_FOREIGN_KEYS;
 
-	innobase_hton->release_temporary_latches =
-		innobase_release_temporary_latches;
-
 #ifdef MYSQL_REPLACE_TRX_IN_THD
         innobase_hton->replace_native_transaction_in_thd =
                 innodb_replace_trx_in_thd;
@@ -4808,12 +4763,6 @@ innobase_commit_ordered(
 	trx = check_trx_exists(thd);
 	TrxInInnoDB	trx_in_innodb(trx);
 
-	/* Since we will reserve the kernel mutex, we must not be holding the
-	search system latch, or we will disobey the latching order. But we
-	already released it in innobase_xa_prepare() (if not before), so just
-	have an assert here.*/
-	trx_assert_no_search_latch(trx);
-
 	if (!trx_is_registered_for_2pc(trx) && trx_is_started(trx)) {
 		/* We cannot throw error here; instead we will catch this error
 		again in innobase_commit() and report it from there. */
@@ -5025,12 +4974,6 @@ innobase_rollback_trx(
 	DBUG_ENTER("innobase_rollback_trx");
 	DBUG_PRINT("trans", ("aborting transaction"));
 
-	/* Release a possible FIFO ticket and search latch. Since we will
-	reserve the trx_sys->mutex, we have to release the search system
-	latch first to obey the latching order. */
-
-	trx_assert_no_search_latch(trx);
-
 	innobase_srv_conc_force_exit_innodb(trx);
 
 	/* If we had reserved the auto-inc lock for some table (if
@@ -6540,37 +6483,19 @@ initialize_auto_increment(dict_table_t* table, const Field* field)
 	dict_table_autoinc_unlock(table);
 }
 
-/*****************************************************************//**
-Creates and opens a handle to a table which already exists in an InnoDB
-database.
-@return 1 if error, 0 if success */
-
+/** Open an InnoDB table
+@param[in]	name	table name
+@return	error code
+@retval	0	on success */
 int
-ha_innobase::open(
-/*==============*/
-	const char*		name,		/*!< in: table name */
-	int			mode,		/*!< in: not used */
-	uint			test_if_locked)	/*!< in: not used */
+ha_innobase::open(const char* name, int, uint)
 {
 	dict_table_t*		ib_table;
 	char			norm_name[FN_REFLEN];
-	THD*			thd;
 	dict_err_ignore_t	ignore_err = DICT_ERR_IGNORE_NONE;
 
 	DBUG_ENTER("ha_innobase::open");
 
-	UT_NOT_USED(mode);
-	UT_NOT_USED(test_if_locked);
-
-	thd = ha_thd();
-
-	/* Under some cases MySQL seems to call this function while
-	holding search latch(es). This breaks the latching order as
-	we acquire dict_sys->mutex below and leads to a deadlock. */
-	if (thd != NULL) {
-		innobase_release_temporary_latches(ht, thd);
-	}
-
 	normalize_table_name(norm_name, name);
 
 	m_user_thd = NULL;
@@ -6585,6 +6510,7 @@ ha_innobase::open(
 	m_upd_buf_size = 0;
 
 	char*	is_part = is_partition(norm_name);
+	THD*	thd = ha_thd();
 
 	/* Check whether FOREIGN_KEY_CHECKS is set to 0. If so, the table
 	can be opened even if some FK indexes are missing. If not, the table
@@ -7055,12 +6981,6 @@ ha_innobase::close()
 {
 	DBUG_ENTER("ha_innobase::close");
 
-	THD*	thd = ha_thd();
-
-	if (thd != NULL) {
-		innobase_release_temporary_latches(ht, thd);
-	}
-
 	row_prebuilt_free(m_prebuilt, FALSE);
 
 	if (m_upd_buf != NULL) {
@@ -13156,10 +13076,6 @@ create_table_info_t::initialize()
 
 	parent_trx = check_trx_exists(m_thd);
 
-	/* In case MySQL calls this in the middle of a SELECT query, release
-	possible adaptive hash latch to avoid deadlocks of threads */
-
-	trx_assert_no_search_latch(parent_trx);
 	DBUG_RETURN(0);
 }
 
@@ -14012,12 +13928,6 @@ innobase_drop_database(
 
 	THD*	thd = current_thd;
 
-	/* In case MySQL calls this in the middle of a SELECT
-	query, release possible adaptive hash latch to avoid
-	deadlocks of threads */
-
-	trx_assert_no_search_latch(check_trx_exists(thd));
-
 	ulint	len = 0;
 	char*	ptr = strend(path) - 2;
 
@@ -14751,12 +14661,7 @@ ha_innobase::info_low(
 
 	update_thd(ha_thd());
 
-	/* In case MySQL calls this in the middle of a SELECT query, release
-	possible adaptive hash latch to avoid deadlocks of threads */
-
-	m_prebuilt->trx->op_info = (char*)"returning various info to MariaDB";
-
-	trx_assert_no_search_latch(m_prebuilt->trx);
+	m_prebuilt->trx->op_info = "returning various info to MariaDB";
 
 	ib_table = m_prebuilt->table;
 	DBUG_ASSERT(ib_table->n_ref_count > 0);
@@ -15603,12 +15508,7 @@ ha_innobase::update_table_comment(
 
 	update_thd(ha_thd());
 
-	m_prebuilt->trx->op_info = (char*)"returning table comment";
-
-	/* In case MySQL calls this in the middle of a SELECT query, release
-	possible adaptive hash latch to avoid deadlocks of threads */
-
-	trx_assert_no_search_latch(m_prebuilt->trx);
+	m_prebuilt->trx->op_info = "returning table comment";
 
 #define SSTR( x ) reinterpret_cast< std::ostringstream & >(		\
         ( std::ostringstream() << std::dec << x ) ).str()
@@ -15664,22 +15564,14 @@ ha_innobase::get_foreign_key_create_info(void)
 
 	update_thd(ha_thd());
 
-	m_prebuilt->trx->op_info = (char*)"getting info on foreign keys";
-
-	/* In case MySQL calls this in the middle of a SELECT query,
-	release possible adaptive hash latch to avoid
-	deadlocks of threads */
-
-	trx_assert_no_search_latch(m_prebuilt->trx);
-
-
+	m_prebuilt->trx->op_info = "getting info on foreign keys";
 
 	/* Output the data to a temporary string */
 	std::string str = dict_print_info_on_foreign_keys(
 		TRUE, m_prebuilt->trx,
 		m_prebuilt->table);
 
-	m_prebuilt->trx->op_info = (char*)"";
+	m_prebuilt->trx->op_info = "";
 
 	/* Allocate buffer for the string */
 	char* fk_str = (char*) my_malloc(str.length() + 1, MYF(0));
@@ -16682,8 +16574,6 @@ innodb_show_status(
 
 	trx_t*	trx = check_trx_exists(thd);
 
-	trx_assert_no_search_latch(trx);
-
 	innobase_srv_conc_force_exit_innodb(trx);
 
 	TrxInInnoDB	trx_in_innodb(trx);
@@ -17999,12 +17889,6 @@ innobase_xa_prepare(
 
 	thd_get_xid(thd, (MYSQL_XID*) trx->xid);
 
-	/* Release a possible FIFO ticket and search latch. Since we will
-	reserve the trx_sys->mutex, we have to release the search system
-	latch first to obey the latching order. */
-
-	trx_assert_no_search_latch(trx);
-
 	innobase_srv_conc_force_exit_innodb(trx);
 
 	TrxInInnoDB	trx_in_innodb(trx);
@@ -21333,7 +21217,7 @@ static MYSQL_SYSVAR_LONG(log_buffer_size, innobase_log_buffer_size,
 static MYSQL_SYSVAR_LONGLONG(log_file_size, innobase_log_file_size,
   PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
   "Size of each log file in a log group.",
-  NULL, NULL, 48*1024*1024L, 4*1024*1024L, LLONG_MAX, 1024*1024L);
+  NULL, NULL, 48 << 20, 1 << 20, 512ULL << 30, 1 << 20);
 
 static MYSQL_SYSVAR_ULONG(log_files_in_group, srv_n_log_files,
   PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
diff --git a/storage/innobase/handler/ha_innodb.h b/storage/innobase/handler/ha_innodb.h
index 717781fd65c..f9ad2007a5f 100644
--- a/storage/innobase/handler/ha_innodb.h
+++ b/storage/innobase/handler/ha_innodb.h
@@ -906,18 +906,6 @@ innodb_base_col_setup_for_stored(
 /** whether this is a computed virtual column */
 #define innobase_is_v_fld(field) ((field)->vcol_info && !(field)->stored_in_db())
 
-/** Release temporary latches.
-Call this function when mysqld passes control to the client. That is to
-avoid deadlocks on the adaptive hash S-latch possibly held by thd. For more
-documentation, see handler.cc.
-@param[in]	hton	Handlerton.
-@param[in]	thd	MySQL thread.
-@return 0 */
-int
-innobase_release_temporary_latches(
-	handlerton*	hton,
-	THD*		thd);
-
 /** Always normalize table name to lower case on Windows */
 #ifdef _WIN32
 #define normalize_table_name(norm_name, name)           \
diff --git a/storage/innobase/handler/ha_innopart.cc b/storage/innobase/handler/ha_innopart.cc
index 1041871805e..fb6f4b89a41 100644
--- a/storage/innobase/handler/ha_innopart.cc
+++ b/storage/innobase/handler/ha_innopart.cc
@@ -932,7 +932,6 @@ ha_innopart::open(
 {
 	dict_table_t*	ib_table;
 	char		norm_name[FN_REFLEN];
-	THD*		thd;
 
 	DBUG_ENTER("ha_innopart::open");
 
@@ -942,16 +941,11 @@ ha_innopart::open(
 		ut_ad(table->part_info != NULL);
 		m_part_info = table->part_info;
 	}
-	thd = ha_thd();
 
 	/* Under some cases MySQL seems to call this function while
 	holding search latch(es). This breaks the latching order as
 	we acquire dict_sys->mutex below and leads to a deadlock. */
 
-	if (thd != NULL) {
-		innobase_release_temporary_latches(ht, thd);
-	}
-
 	normalize_table_name(norm_name, name);
 
 	m_user_thd = NULL;
@@ -1017,6 +1011,7 @@ share_error:
 	MONITOR_INC(MONITOR_TABLE_OPEN);
 
 	bool	no_tablespace;
+	THD*	thd = ha_thd();
 
 	/* TODO: Should we do this check for every partition during ::open()? */
 	/* TODO: refactor this in ha_innobase so it can increase code reuse. */
@@ -1372,15 +1367,8 @@ void ha_innopart::clear_ins_upd_nodes()
 int
 ha_innopart::close()
 {
-	THD*	thd;
-
 	DBUG_ENTER("ha_innopart::close");
 
-	thd = ha_thd();
-	if (thd != NULL) {
-		innobase_release_temporary_latches(ht, thd);
-	}
-
 	ut_ad(m_pcur_parts == NULL);
 	ut_ad(m_clust_pcur_parts == NULL);
 	close_partitioning();
@@ -3032,11 +3020,6 @@ ha_innopart::records_in_range(
 
 	m_prebuilt->trx->op_info = (char*)"estimating records in index range";
 
-	/* In case MySQL calls this in the middle of a SELECT query, release
-	possible adaptive hash latch to avoid deadlocks of threads. */
-
-	trx_assert_no_search_latch(m_prebuilt->trx);
-
 	active_index = keynr;
 
 	key = table->key_info + active_index;
@@ -3171,11 +3154,6 @@ ha_innopart::estimate_rows_upper_bound()
 
 	m_prebuilt->trx->op_info = "calculating upper bound for table rows";
 
-	/* In case MySQL calls this in the middle of a SELECT query, release
-	possible adaptive hash latch to avoid deadlocks of threads. */
-
-	trx_assert_no_search_latch(m_prebuilt->trx);
-
 	for (uint i = m_part_info->get_first_used_partition();
 	     i < m_tot_parts;
 	     i = m_part_info->get_next_used_partition(i)) {
@@ -3287,12 +3265,7 @@ ha_innopart::info_low(
 
 	update_thd(ha_thd());
 
-	/* In case MySQL calls this in the middle of a SELECT query, release
-	possible adaptive hash latch to avoid deadlocks of threads. */
-
-	m_prebuilt->trx->op_info = (char*)"returning various info to MySQL";
-
-	trx_assert_no_search_latch(m_prebuilt->trx);
+	m_prebuilt->trx->op_info = "returning various info to MySQL";
 
 	ut_ad(m_part_share->get_table_part(0)->n_ref_count > 0);
 
diff --git a/storage/innobase/handler/handler0alter.cc b/storage/innobase/handler/handler0alter.cc
index 416dd231e10..1eec22874d1 100644
--- a/storage/innobase/handler/handler0alter.cc
+++ b/storage/innobase/handler/handler0alter.cc
@@ -591,7 +591,6 @@ ha_innobase::check_if_supported_inplace_alter(
 	}
 
 	update_thd();
-	trx_assert_no_search_latch(m_prebuilt->trx);
 
 	/* Change on engine specific table options require rebuild of the
 	table */
diff --git a/storage/innobase/handler/i_s.cc b/storage/innobase/handler/i_s.cc
index 36ecc0b8a29..8f04f9d15ee 100644
--- a/storage/innobase/handler/i_s.cc
+++ b/storage/innobase/handler/i_s.cc
@@ -699,8 +699,7 @@ fill_innodb_trx_from_cache(
 
 #ifdef BTR_CUR_HASH_ADAPT
 		/* trx_adaptive_hash_latched */
-		OK(fields[IDX_TRX_ADAPTIVE_HASH_LATCHED]->store(
-			   row->trx_has_search_latch, true));
+		OK(fields[IDX_TRX_ADAPTIVE_HASH_LATCHED]->store(0, true));
 #endif /* BTR_CUR_HASH_ADAPT */
 
 		/* trx_is_read_only*/
diff --git a/storage/innobase/include/log0log.ic b/storage/innobase/include/log0log.ic
index 82a94265776..1e09c263975 100644
--- a/storage/innobase/include/log0log.ic
+++ b/storage/innobase/include/log0log.ic
@@ -1,6 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1995, 2015, Oracle and/or its affiliates. All Rights Reserved.
+Copyright (c) 2017, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -479,11 +480,11 @@ void
 log_free_check(void)
 /*================*/
 {
-#ifdef UNIV_DEBUG
 	/* During row_log_table_apply(), this function will be called while we
 	are holding some latches. This is OK, as long as we are not holding
 	any latches on buffer blocks. */
 
+#ifdef UNIV_DEBUG
 	static const latch_level_t latches[] = {
 		SYNC_DICT,		/* dict_sys->mutex during
 					commit_try_rebuild() */
@@ -491,13 +492,12 @@ log_free_check(void)
 					commit_try_rebuild() */
 		SYNC_INDEX_TREE		/* index->lock */
 	};
-
-	sync_allowed_latches check(
-		latches, latches + sizeof(latches)/sizeof(*latches));
-
-        ut_ad(!sync_check_iterate(check));
 #endif /* UNIV_DEBUG */
 
+	ut_ad(!sync_check_iterate(
+		      sync_allowed_latches(latches,
+					   latches + UT_ARR_SIZE(latches))));
+
 	if (log_sys->check_flush_or_checkpoint) {
 
 		log_check_margins();
diff --git a/storage/innobase/include/sync0debug.h b/storage/innobase/include/sync0debug.h
index ba697b70e13..ecc742918f0 100644
--- a/storage/innobase/include/sync0debug.h
+++ b/storage/innobase/include/sync0debug.h
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 2013, 2015, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2017, MariaDB Corporation. All Rights Reserved.
+Copyright (c) 2017, MariaDB Corporation.
 
 Portions of this file contain modifications contributed and copyrighted by
 Google, Inc. Those modifications are gratefully acknowledged and are described
@@ -84,10 +84,10 @@ sync_check_find(latch_level_t level);
 
 /** Checks that the level array for the current thread is empty.
 Terminate iteration if the functor returns true.
-@param[in,out]	 functor	called for each element.
-@return true if the functor returns true */
+@param[in]	 functor	called for each element.
+@return true if the functor returns true for any element */
 bool
-sync_check_iterate(sync_check_functor_t& functor);
+sync_check_iterate(const sync_check_functor_t& functor);
 
 /** Acquires the debug mutex. We cannot use the mutex defined in sync0sync,
 because the debug mutex is also acquired in sync0arr while holding the OS
diff --git a/storage/innobase/include/sync0types.h b/storage/innobase/include/sync0types.h
index ec4503daa64..8a68f3d0cc6 100644
--- a/storage/innobase/include/sync0types.h
+++ b/storage/innobase/include/sync0types.h
@@ -1078,108 +1078,43 @@ struct latch_t {
 
 /** Subclass this to iterate over a thread's acquired latch levels. */
 struct sync_check_functor_t {
-	virtual ~sync_check_functor_t() { }
-	virtual bool operator()(const latch_level_t) = 0;
-	virtual bool result() const = 0;
+	virtual bool operator()(const latch_level_t) const = 0;
 };
 
-#ifdef BTR_CUR_HASH_ADAPT
-/** Functor to check whether the calling thread owns the btr search mutex. */
-struct btrsea_sync_check : public sync_check_functor_t {
-
-	/** Constructor
-	@param[in]	has_search_latch	true if owns the latch */
-	explicit btrsea_sync_check(bool has_search_latch)
-		:
-		m_result(),
-		m_has_search_latch(has_search_latch) { }
-
-	/** Destructor */
-	virtual ~btrsea_sync_check() { }
-
-	/** Called for every latch owned by the calling thread.
-	@param[in]	level		Level of the existing latch
-	@return true if the predicate check is successful */
-	virtual bool operator()(const latch_level_t level)
-	{
-		/* If calling thread doesn't hold search latch then
-		check if there are latch level exception provided. */
-
-		if (!m_has_search_latch
-		    && (level != SYNC_SEARCH_SYS
-			&& level != SYNC_FTS_CACHE)) {
-
-			m_result = true;
-
-			return(m_result);
-		}
-
-		return(false);
-	}
-
-	/** @return result from the check */
-	virtual bool result() const
-	{
-		return(m_result);
-	}
-
-private:
-	/** True if all OK */
-	bool		m_result;
-
-	/** If the caller owns the search latch */
-	const bool	m_has_search_latch;
-};
-#endif /* BTR_CUR_HASH_ADAPT */
-
-/** Functor to check for dictionay latching constraints. */
-struct dict_sync_check : public sync_check_functor_t {
-
-	/** Constructor
-	@param[in]	dict_mutex_allow	true if the dict mutex
-						is allowed */
-	explicit dict_sync_check(bool dict_mutex_allowed)
-		:
-		m_result(),
-		m_dict_mutex_allowed(dict_mutex_allowed) { }
-
-	/** Destructor */
-	virtual ~dict_sync_check() { }
-
+/** Check that no latch is being held.
+@tparam	some_allowed	whether some latches are allowed to be held */
+template<bool some_allowed = false>
+struct sync_checker : public sync_check_functor_t
+{
 	/** Check the latching constraints
-	@param[in]	level		The level held by the thread */
-	virtual bool operator()(const latch_level_t level)
+	@param[in]	level		The level held by the thread
+	@return whether a latch violation was detected */
+	bool operator()(const latch_level_t level) const
 	{
-		if (!m_dict_mutex_allowed
-		    || (level != SYNC_DICT
-			&& level != SYNC_DICT_OPERATION
-			&& level != SYNC_FTS_CACHE
-			/* This only happens in recv_apply_hashed_log_recs. */
-			&& level != SYNC_RECV_WRITER
-			&& level != SYNC_NO_ORDER_CHECK)) {
-
-			m_result = true;
-
-			return(true);
+		if (some_allowed) {
+			switch (level) {
+			case SYNC_RECV_WRITER:
+				/* This only happens in
+				recv_apply_hashed_log_recs. */
+			case SYNC_DICT:
+			case SYNC_DICT_OPERATION:
+			case SYNC_FTS_CACHE:
+			case SYNC_NO_ORDER_CHECK:
+				return(false);
+			default:
+				return(true);
+			}
 		}
 
-		return(false);
-	}
-
-	/** @return the result of the check */
-	virtual bool result() const
-	{
-		return(m_result);
+		return(true);
 	}
-
-private:
-	/** True if all OK */
-	bool		m_result;
-
-	/** True if it is OK to hold the dict mutex */
-	const bool	m_dict_mutex_allowed;
 };
 
+/** The strict latch checker (no InnoDB latches may be held) */
+typedef struct sync_checker<false> sync_check;
+/** The sloppy latch checker (can hold InnoDB dictionary or SQL latches) */
+typedef struct sync_checker<true> dict_sync_check;
+
 /** Functor to check for given latching constraints. */
 struct sync_allowed_latches : public sync_check_functor_t {
 
@@ -1189,9 +1124,7 @@ struct sync_allowed_latches : public sync_check_functor_t {
 	sync_allowed_latches(
 		const latch_level_t*	from,
 		const latch_level_t*	to)
-		:
-		m_result(),
-		m_latches(from, to) { }
+		: begin(from), end(to) { }
 
 	/** Checks whether the given latch_t violates the latch constraint.
 	This object maintains a list of allowed latch levels, and if the given
@@ -1199,41 +1132,17 @@ struct sync_allowed_latches : public sync_check_functor_t {
 	then it is a violation.
 
 	@param[in]	latch	The latch level to check
-	@return true if there is a latch ordering violation */
-	virtual bool operator()(const latch_level_t level)
+	@return true if there is a latch violation */
+	bool operator()(const latch_level_t level) const
 	{
-		for (latches_t::const_iterator it = m_latches.begin();
-		     it != m_latches.end();
-		     ++it) {
-
-			if (level == *it) {
-
-				m_result = false;
-
-				/* No violation */
-				return(false);
-			}
-		}
-
-		return(true);
-	}
-
-	/** @return the result of the check */
-	virtual bool result() const
-	{
-		return(m_result);
+		return(std::find(begin, end, level) == end);
 	}
 
 private:
-	/** Save the result of validation check here
-	True if all OK */
-	bool		m_result;
-
-	typedef std::vector<latch_level_t, ut_allocator<latch_level_t> >
-		latches_t;
-
-	/** List of latch levels that are allowed to be held */
-	latches_t	m_latches;
+	/** First element in an array of allowed latch levels */
+	const latch_level_t* const begin;
+	/** First element after the end of the array of allowed latch levels */
+	const latch_level_t* const end;
 };
 
 /** Get the latch id from a latch name.
diff --git a/storage/innobase/include/trx0i_s.h b/storage/innobase/include/trx0i_s.h
index 17a297527af..e02c5d88a29 100644
--- a/storage/innobase/include/trx0i_s.h
+++ b/storage/innobase/include/trx0i_s.h
@@ -1,6 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 2007, 2015, Oracle and/or its affiliates. All Rights Reserved.
+Copyright (c) 2017, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -162,10 +163,6 @@ struct i_s_trx_row_t {
 					/*!< check_foreigns in trx_t */
 	const char*	trx_foreign_key_error;
 					/*!< detailed_error in trx_t */
-#ifdef BTR_CUR_HASH_ADAPT
-	ibool		trx_has_search_latch;
-					/*!< has_search_latch in trx_t */
-#endif /* BTR_CUR_HASH_ADAPT */
 	ulint		trx_is_read_only;
 					/*!< trx_t::read_only */
 	ulint		trx_is_autocommit_non_locking;
diff --git a/storage/innobase/include/trx0trx.h b/storage/innobase/include/trx0trx.h
index 6274dec9f9d..b2d4952318c 100644
--- a/storage/innobase/include/trx0trx.h
+++ b/storage/innobase/include/trx0trx.h
@@ -58,15 +58,6 @@ class FlushObserver;
 /** Dummy session used currently in MySQL interface */
 extern sess_t*	trx_dummy_sess;
 
-#ifdef BTR_CUR_HASH_ADAPT
-/** Assert that the transaction is not holding the adaptive hash index latch.
-@param[in] trx		transaction */
-# define trx_assert_no_search_latch(trx) \
-	ut_ad(!trx->has_search_latch)
-#else /* BTR_CUR_HASH_ADAPT */
-# define trx_assert_no_search_latch(trx)
-#endif
-
 /** Set flush observer for the transaction
 @param[in/out]	trx		transaction struct
 @param[in]	observer	flush observer */
@@ -1072,11 +1063,6 @@ struct trx_t {
 					flush the log in
 					trx_commit_complete_for_mysql() */
 	ulint		duplicates;	/*!< TRX_DUP_IGNORE | TRX_DUP_REPLACE */
-#ifdef BTR_CUR_HASH_ADAPT
-	bool		has_search_latch;
-					/*!< TRUE if this trx has latched the
-					search system latch in S-mode */
-#endif /* BTR_CUR_HASH_ADAPT */
 	trx_dict_op_t	dict_operation;	/**< @see enum trx_dict_op_t */
 
 	/* Fields protected by the srv_conc_mutex. */
@@ -1508,17 +1494,11 @@ private:
 		}
 
 		/* Avoid excessive mutex acquire/release */
-		if (++trx->in_depth > 1) {
+		if (trx->in_depth++) {
 			/* The transaction is already inside InnoDB. */
-			ut_ad(trx->in_depth > 1);
 			return;
 		}
 
-		/* Only the owning thread should release the latch. */
-
-		ut_ad(trx->in_depth == 1);
-		trx_assert_no_search_latch(trx);
-
 		trx_mutex_enter(trx);
 
 		wait(trx);
@@ -1543,16 +1523,10 @@ private:
 
 		ut_ad(trx->in_depth > 0);
 
-		if (--trx->in_depth > 0) {
-			ut_ad(trx->in_depth);
+		if (--trx->in_depth) {
 			return;
 		}
 
-		/* Only the owning thread should release the latch. */
-
-		ut_ad(trx->in_depth == 0);
-		trx_assert_no_search_latch(trx);
-
 		trx_mutex_enter(trx);
 
 		ut_ad((trx->in_innodb & TRX_FORCE_ROLLBACK_MASK) > 0);
diff --git a/storage/innobase/log/log0log.cc b/storage/innobase/log/log0log.cc
index d8e4ba6fe98..4f924e064a8 100644
--- a/storage/innobase/log/log0log.cc
+++ b/storage/innobase/log/log0log.cc
@@ -677,14 +677,13 @@ log_set_capacity()
 {
 	lsn_t		margin;
 	ulint		free;
-	bool		success	= true;
-	lsn_t		smallest_capacity;
 
-	log_mutex_enter();
-
-	smallest_capacity = log_group_get_capacity(&log_sys->log);
+	lsn_t smallest_capacity = ((srv_log_file_size_requested
+				    << srv_page_size_shift)
+				   - LOG_FILE_HDR_SIZE)
+		* srv_n_log_files;
 	/* Add extra safety */
-	smallest_capacity = smallest_capacity - smallest_capacity / 10;
+	smallest_capacity -= smallest_capacity / 10;
 
 	/* For each OS thread we must reserve so much free space in the
 	smallest log group that it can accommodate the log entries produced
@@ -694,15 +693,20 @@ log_set_capacity()
 	free = LOG_CHECKPOINT_FREE_PER_THREAD * (10 + srv_thread_concurrency)
 		+ LOG_CHECKPOINT_EXTRA_FREE;
 	if (free >= smallest_capacity / 2) {
-		success = false;
-
-		goto failure;
-	} else {
-		margin = smallest_capacity - free;
+		ib::error() << "Cannot continue operation. ib_logfiles are too"
+			" small for innodb_thread_concurrency="
+			<< srv_thread_concurrency << ". The combined size of"
+			" ib_logfiles should be bigger than"
+			" 200 kB * innodb_thread_concurrency. "
+			<< INNODB_PARAMETERS_MSG;
+		return(false);
 	}
 
+	margin = smallest_capacity - free;
 	margin = margin - margin / 10;	/* Add still some extra safety */
 
+	log_mutex_enter();
+
 	log_sys->log_group_capacity = smallest_capacity;
 
 	log_sys->max_modified_age_async = margin
@@ -714,19 +718,9 @@ log_set_capacity()
 		/ LOG_POOL_CHECKPOINT_RATIO_ASYNC;
 	log_sys->max_checkpoint_age = margin;
 
-failure:
 	log_mutex_exit();
 
-	if (!success) {
-		ib::error() << "Cannot continue operation. ib_logfiles are too"
-			" small for innodb_thread_concurrency="
-			<< srv_thread_concurrency << ". The combined size of"
-			" ib_logfiles should be bigger than"
-			" 200 kB * innodb_thread_concurrency. "
-			<< INNODB_PARAMETERS_MSG;
-	}
-
-	return(success);
+	return(true);
 }
 
 /** Initializes the redo logging subsystem. */
diff --git a/storage/innobase/row/row0sel.cc b/storage/innobase/row/row0sel.cc
index 3bae9bd25ac..fd0205ad153 100644
--- a/storage/innobase/row/row0sel.cc
+++ b/storage/innobase/row/row0sel.cc
@@ -2231,16 +2231,7 @@ stop_for_a_while:
 	btr_pcur_store_position(&(plan->pcur), &mtr);
 
 	mtr_commit(&mtr);
-
-#ifdef BTR_CUR_HASH_ADAPT
-# ifdef UNIV_DEBUG
-	{
-		btrsea_sync_check	check(true);
-
-		ut_ad(!sync_check_iterate(check));
-	}
-# endif /* UNIV_DEBUG */
-#endif /* BTR_CUR_HASH_ADAPT */
+	ut_ad(!sync_check_iterate(sync_check()));
 
 	err = DB_SUCCESS;
 	goto func_exit;
@@ -2258,14 +2249,7 @@ commit_mtr_for_a_while:
 	mtr_commit(&mtr);
 
 	mtr_has_extra_clust_latch = FALSE;
-
-#ifdef UNIV_DEBUG
-	{
-		dict_sync_check	check(true);
-
-		ut_ad(!sync_check_iterate(check));
-	}
-#endif /* UNIV_DEBUG */
+	ut_ad(!sync_check_iterate(dict_sync_check()));
 
 	goto table_loop;
 
@@ -2280,20 +2264,13 @@ lock_wait_or_error:
 
 	mtr_commit(&mtr);
 
-#ifdef UNIV_DEBUG
-	{
-		dict_sync_check	check(true);
-
-		ut_ad(!sync_check_iterate(check));
-	}
-#endif /* UNIV_DEBUG */
-
 func_exit:
 #ifdef BTR_CUR_HASH_ADAPT
 	if (search_latch_locked) {
 		btr_search_s_unlock(index);
 	}
 #endif /* BTR_CUR_HASH_ADAPT */
+	ut_ad(!sync_check_iterate(dict_sync_check()));
 
 	if (heap != NULL) {
 		mem_heap_free(heap);
@@ -3041,7 +3018,6 @@ row_sel_store_mysql_field_func(
 		mem_heap_t*	heap;
 		/* Copy an externally stored field to a temporary heap */
 
-		trx_assert_no_search_latch(prebuilt->trx);
 		ut_ad(field_no == templ->clust_rec_field_no);
 		ut_ad(templ->type != DATA_POINT);
 
@@ -3928,11 +3904,7 @@ row_sel_try_search_shortcut_for_mysql(
 	ut_ad(!prebuilt->templ_contains_blob);
 
 	btr_pcur_open_with_no_init(index, search_tuple, PAGE_CUR_GE,
-				   BTR_SEARCH_LEAF, pcur,
-				   (trx->has_search_latch)
-				    ? RW_S_LATCH
-				    : 0,
-				   mtr);
+				   BTR_SEARCH_LEAF, pcur, RW_S_LATCH, mtr);
 	rec = btr_pcur_get_rec(pcur);
 
 	if (!page_rec_is_user_rec(rec)) {
@@ -4190,14 +4162,7 @@ row_search_mvcc(
 		DBUG_RETURN(DB_END_OF_INDEX);
 	}
 
-#ifdef BTR_CUR_HASH_ADAPT
-# ifdef UNIV_DEBUG
-	{
-		btrsea_sync_check	check(trx->has_search_latch);
-		ut_ad(!sync_check_iterate(check));
-	}
-# endif /* UNIV_DEBUG */
-#endif /* BTR_CUR_HASH_ADAPT */
+	ut_ad(!sync_check_iterate(sync_check()));
 
 	if (dict_table_is_discarded(prebuilt->table)) {
 
@@ -4222,8 +4187,6 @@ row_search_mvcc(
 		&& (prebuilt->read_just_key
 		    || prebuilt->m_read_virtual_key);
 
-	trx_assert_no_search_latch(trx);
-
 	/* Reset the new record lock info if srv_locks_unsafe_for_binlog
 	is set or session is using a READ COMMITED isolation level. Then
 	we are able to remove the record locks set here on an individual
@@ -4378,9 +4341,7 @@ row_search_mvcc(
 			and if we try that, we can deadlock on the adaptive
 			hash index semaphore! */
 
-			trx_assert_no_search_latch(trx);
 			rw_lock_s_lock(btr_get_search_latch(index));
-			trx->has_search_latch = true;
 
 			switch (row_sel_try_search_shortcut_for_mysql(
 					&rec, prebuilt, &offsets, &heap,
@@ -4435,7 +4396,6 @@ row_search_mvcc(
 				err = DB_SUCCESS;
 
 				rw_lock_s_unlock(btr_get_search_latch(index));
-				trx->has_search_latch = false;
 
 				goto func_exit;
 
@@ -4446,7 +4406,6 @@ row_search_mvcc(
 				err = DB_RECORD_NOT_FOUND;
 
 				rw_lock_s_unlock(btr_get_search_latch(index));
-				trx->has_search_latch = false;
 
 				/* NOTE that we do NOT store the cursor
 				position */
@@ -4464,7 +4423,6 @@ row_search_mvcc(
 			mtr_start(&mtr);
 
                         rw_lock_s_unlock(btr_get_search_latch(index));
-                        trx->has_search_latch = false;
 		}
 	}
 #endif /* BTR_CUR_HASH_ADAPT */
@@ -4472,8 +4430,6 @@ row_search_mvcc(
 	/*-------------------------------------------------------------*/
 	/* PHASE 3: Open or restore index cursor position */
 
-	trx_assert_no_search_latch(trx);
-
 	spatial_search = dict_index_is_spatial(index)
 			 && mode >= PAGE_CUR_CONTAIN;
 
@@ -5787,15 +5743,7 @@ func_exit:
 		}
 	}
 
-#ifdef BTR_CUR_HASH_ADAPT
-# ifdef UNIV_DEBUG
-	{
-		btrsea_sync_check	check(trx->has_search_latch);
-
-		ut_ad(!sync_check_iterate(check));
-	}
-# endif /* UNIV_DEBUG */
-#endif /* BTR_CUR_HASH_ADAPT */
+	ut_ad(!sync_check_iterate(sync_check()));
 
 	DEBUG_SYNC_C("innodb_row_search_for_mysql_exit");
 
diff --git a/storage/innobase/srv/srv0conc.cc b/storage/innobase/srv/srv0conc.cc
index bf8a326a633..9f589b57d9c 100644
--- a/storage/innobase/srv/srv0conc.cc
+++ b/storage/innobase/srv/srv0conc.cc
@@ -197,11 +197,6 @@ srv_conc_enter_innodb_with_atomics(
 			(void) my_atomic_addlint(
 				&srv_conc.n_waiting, 1);
 
-			/* Release possible search system latch this
-			thread has */
-
-			trx_assert_no_search_latch(trx);
-
 			thd_wait_begin(trx->mysql_thd, THD_WAIT_USER_LOCK);
 
 			notified_mysql = TRUE;
@@ -257,15 +252,7 @@ srv_conc_enter_innodb(
 {
 	trx_t*	trx	= prebuilt->trx;
 
-#ifdef BTR_CUR_HASH_ADAPT
-# ifdef UNIV_DEBUG
-	{
-		btrsea_sync_check	check(trx->has_search_latch);
-
-		ut_ad(!sync_check_iterate(check));
-	}
-# endif /* UNIV_DEBUG */
-#endif /* BTR_CUR_HASH_ADAPT */
+	ut_ad(!sync_check_iterate(sync_check()));
 
 	srv_conc_enter_innodb_with_atomics(trx);
 }
@@ -279,15 +266,7 @@ srv_conc_force_enter_innodb(
 	trx_t*	trx)	/*!< in: transaction object associated with the
 			thread */
 {
-#ifdef BTR_CUR_HASH_ADAPT
-# ifdef UNIV_DEBUG
-	{
-		btrsea_sync_check	check(trx->has_search_latch);
-
-		ut_ad(!sync_check_iterate(check));
-	}
-# endif /* UNIV_DEBUG */
-#endif /* BTR_CUR_HASH_ADAPT */
+	ut_ad(!sync_check_iterate(sync_check()));
 
 	if (!srv_thread_concurrency) {
 
@@ -320,15 +299,7 @@ srv_conc_force_exit_innodb(
 
 	srv_conc_exit_innodb_with_atomics(trx);
 
-#ifdef BTR_CUR_HASH_ADAPT
-# ifdef UNIV_DEBUG
-	{
-		btrsea_sync_check	check(trx->has_search_latch);
-
-		ut_ad(!sync_check_iterate(check));
-	}
-# endif /* UNIV_DEBUG */
-#endif /* BTR_CUR_HASH_ADAPT */
+	ut_ad(!sync_check_iterate(sync_check()));
 }
 
 /*********************************************************************//**
diff --git a/storage/innobase/sync/sync0debug.cc b/storage/innobase/sync/sync0debug.cc
index 11743e14be2..e43e87eb14e 100644
--- a/storage/innobase/sync/sync0debug.cc
+++ b/storage/innobase/sync/sync0debug.cc
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 2014, 2016, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2017, MariaDB Corporation. All Rights Reserved.
+Copyright (c) 2017, MariaDB Corporation.
 
 Portions of this file contain modifications contributed and copyrighted by
 Google, Inc. Those modifications are gratefully acknowledged and are described
@@ -298,29 +298,23 @@ struct LatchDebug {
 	}
 
 	/** Iterate over a thread's latches.
-	@param[in,out]	functor		The callback
+	@param[in]	functor		The callback
 	@return true if the functor returns true. */
-	bool for_each(sync_check_functor_t& functor)
+	bool for_each(const sync_check_functor_t& functor)
 		UNIV_NOTHROW
 	{
-		const Latches*	latches = thread_latches();
-
-		if (latches == 0) {
-			return(functor.result());
-		}
-
-		Latches::const_iterator	end = latches->end();
-
-		for (Latches::const_iterator it = latches->begin();
-		     it != end;
-		     ++it) {
-
-			if (functor(it->m_level)) {
-				break;
+		if (const Latches* latches = thread_latches()) {
+			Latches::const_iterator	end = latches->end();
+			for (Latches::const_iterator it = latches->begin();
+			     it != end; ++it) {
+
+				if (functor(it->m_level)) {
+					return(true);
+				}
 			}
 		}
 
-		return(functor.result());
+		return(false);
 	}
 
 	/** Removes a latch from the thread level array if it is found there.
@@ -1215,13 +1209,12 @@ sync_check_find(latch_level_t level)
 
 /** Iterate over the thread's latches.
 @param[in,out]	functor		called for each element.
-@return false if the sync debug hasn't been initialised
-@return the value returned by the functor */
+@return true if the functor returns true for any element */
 bool
-sync_check_iterate(sync_check_functor_t& functor)
+sync_check_iterate(const sync_check_functor_t& functor)
 {
-	if (LatchDebug::instance() != NULL) {
-		return(LatchDebug::instance()->for_each(functor));
+	if (LatchDebug* debug = LatchDebug::instance()) {
+		return(debug->for_each(functor));
 	}
 
 	return(false);
diff --git a/storage/innobase/trx/trx0i_s.cc b/storage/innobase/trx/trx0i_s.cc
index fcc50b8c76d..7854ad2ab5a 100644
--- a/storage/innobase/trx/trx0i_s.cc
+++ b/storage/innobase/trx/trx0i_s.cc
@@ -589,10 +589,6 @@ thd_done:
 		row->trx_foreign_key_error = NULL;
 	}
 
-#ifdef BTR_CUR_HASH_ADAPT
-	row->trx_has_search_latch = (ibool) trx->has_search_latch;
-#endif /* BTR_CUR_HASH_ADAPT */
-
 	row->trx_is_read_only = trx->read_only;
 
 	row->trx_is_autocommit_non_locking = trx_is_autocommit_non_locking(trx);
diff --git a/storage/innobase/trx/trx0trx.cc b/storage/innobase/trx/trx0trx.cc
index 315697403c4..7fdbd808a60 100644
--- a/storage/innobase/trx/trx0trx.cc
+++ b/storage/innobase/trx/trx0trx.cc
@@ -272,8 +272,6 @@ struct TrxFactory {
 
 		ut_a(trx->lock.wait_lock == NULL);
 		ut_a(trx->lock.wait_thr == NULL);
-
-		trx_assert_no_search_latch(trx);
 		ut_a(trx->dict_operation_lock_mode == 0);
 
 		if (trx->lock.lock_heap != NULL) {
@@ -341,9 +339,6 @@ struct TrxFactory {
 
 		ut_a(trx->lock.wait_thr == NULL);
 		ut_a(trx->lock.wait_lock == NULL);
-
-		trx_assert_no_search_latch(trx);
-
 		ut_a(trx->dict_operation_lock_mode == 0);
 
 		ut_a(UT_LIST_GET_LEN(trx->lock.trx_locks) == 0);
@@ -2413,13 +2408,6 @@ state_ok:
 			(ulong) n_rec_locks);
 	}
 
-#ifdef BTR_CUR_HASH_ADAPT
-	if (trx->has_search_latch) {
-		newline = TRUE;
-		fputs(", holds adaptive hash latch", f);
-	}
-#endif /* BTR_CUR_HASH_ADAPT */
-
 	if (trx->undo_no != 0) {
 		newline = TRUE;
 		fprintf(f, ", undo log entries " TRX_ID_FMT, trx->undo_no);
@@ -2551,11 +2539,6 @@ state_ok:
 		fprintf(f, "que state %lu ", (ulong) trx->lock.que_state);
 	}
 
-	if (trx->has_search_latch) {
-		newline = TRUE;
-		fputs(", holds adaptive hash latch", f);
-	}
-
 	if (trx->undo_no != 0) {
 		newline = TRUE;
 		fprintf(f, ", undo log entries " TRX_ID_FMT, trx->undo_no);
diff --git a/storage/myisam/ha_myisam.cc b/storage/myisam/ha_myisam.cc
index 86f3bbb9bc5..871ee77b92b 100644
--- a/storage/myisam/ha_myisam.cc
+++ b/storage/myisam/ha_myisam.cc
@@ -1183,9 +1183,6 @@ int ha_myisam::repair(THD *thd, HA_CHECK &param, bool do_optimize)
   share->state.dupp_key= MI_MAX_KEY;
   strmov(fixed_name,file->filename);
 
-  // Release latches since this can take a long time
-  ha_release_temporary_latches(thd);
-
   /*
     Don't lock tables if we have used LOCK TABLE or if we come from
     enable_index()
diff --git a/storage/xtradb/handler/ha_innodb.cc b/storage/xtradb/handler/ha_innodb.cc
index ba426dd3d3b..6097f87b43d 100644
--- a/storage/xtradb/handler/ha_innodb.cc
+++ b/storage/xtradb/handler/ha_innodb.cc
@@ -2123,39 +2123,6 @@ ha_innobase::is_fake_change_enabled(THD* thd)
 }
 
 /********************************************************************//**
-In XtraDB it is impossible for a transaction to own a search latch outside of
-InnoDB code, so there is nothing to release on demand.  We keep this function to
-simplify maintenance.
-@return 0 */
-static
-int
-innobase_release_temporary_latches(
-/*===============================*/
-	handlerton*	hton MY_ATTRIBUTE((unused)),	/*!< in: handlerton */
-	THD*		thd MY_ATTRIBUTE((unused)))	/*!< in: MySQL thread */
-{
-#ifdef UNIV_DEBUG
-	DBUG_ASSERT(hton == innodb_hton_ptr);
-
-	if (!innodb_inited || thd == NULL) {
-
-		return(0);
-	}
-
-	trx_t*	trx = thd_to_trx(thd);
-
-	if (trx != NULL) {
-#ifdef UNIV_SYNC_DEBUG
-		ut_ad(!btr_search_own_any());
-#endif
-		trx_search_latch_release_if_reserved(trx);
-	}
-#endif
-
-	return(0);
-}
-
-/********************************************************************//**
 Increments innobase_active_counter and every INNOBASE_WAKE_INTERVALth
 time calls srv_active_wake_master_thread. This function should be used
 when a single database operation may introduce a small need for
@@ -3813,9 +3780,6 @@ innobase_init(
 	innobase_hton->flags = HTON_SUPPORTS_EXTENDED_KEYS |
 		HTON_SUPPORTS_FOREIGN_KEYS;
 
-	innobase_hton->release_temporary_latches =
-		innobase_release_temporary_latches;
-
 	innobase_hton->kill_query = innobase_kill_connection;
 
         if (srv_file_per_table)
@@ -6262,9 +6226,6 @@ ha_innobase::open(
 
 	thd = ha_thd();
 
-	/* No-op in XtraDB */
-	innobase_release_temporary_latches(ht, thd);
-
 	normalize_table_name(norm_name, name);
 
 	user_thd = NULL;
@@ -6724,9 +6685,6 @@ ha_innobase::close()
 
 	thd = ha_thd();
 
-	/* No-op in XtraDB */
-	innobase_release_temporary_latches(ht, thd);
-
 	row_prebuilt_free(prebuilt, FALSE);
 
 	if (upd_buf != NULL) {
diff --git a/storage/xtradb/log/log0log.cc b/storage/xtradb/log/log0log.cc
index 3252cd793c9..833f3240369 100644
--- a/storage/xtradb/log/log0log.cc
+++ b/storage/xtradb/log/log0log.cc
@@ -860,43 +860,16 @@ ibool
 log_calc_max_ages(void)
 /*===================*/
 {
-	log_group_t*	group;
 	lsn_t		margin;
 	ulint		free;
-	ibool		success		= TRUE;
-	lsn_t		smallest_capacity;
-	lsn_t		archive_margin;
-	lsn_t		smallest_archive_margin;
-
-	mutex_enter(&(log_sys->mutex));
-
-	group = UT_LIST_GET_FIRST(log_sys->log_groups);
-
-	ut_ad(group);
-
-	smallest_capacity = LSN_MAX;
-	smallest_archive_margin = LSN_MAX;
-
-	while (group) {
-		if (log_group_get_capacity(group) < smallest_capacity) {
 
-			smallest_capacity = log_group_get_capacity(group);
-		}
-
-		archive_margin = log_group_get_capacity(group)
-			- (group->file_size - LOG_FILE_HDR_SIZE)
-			- LOG_ARCHIVE_EXTRA_MARGIN;
-
-		if (archive_margin < smallest_archive_margin) {
-
-			smallest_archive_margin = archive_margin;
-		}
-
-		group = UT_LIST_GET_NEXT(log_groups, group);
-	}
+	lsn_t smallest_capacity = ((srv_log_file_size_requested
+				    << srv_page_size_shift)
+				   - LOG_FILE_HDR_SIZE)
+		* srv_n_log_files;
 
 	/* Add extra safety */
-	smallest_capacity = smallest_capacity - smallest_capacity / 10;
+	smallest_capacity -= smallest_capacity / 10;
 
 	/* For each OS thread we must reserve so much free space in the
 	smallest log group that it can accommodate the log entries produced
@@ -906,15 +879,16 @@ log_calc_max_ages(void)
 	free = LOG_CHECKPOINT_FREE_PER_THREAD * (10 + srv_thread_concurrency)
 		+ LOG_CHECKPOINT_EXTRA_FREE;
 	if (free >= smallest_capacity / 2) {
-		success = FALSE;
-
-		goto failure;
-	} else {
-		margin = smallest_capacity - free;
+		ib_logf(IB_LOG_LEVEL_FATAL,
+			"The combined size of ib_logfiles"
+			" should be bigger than\n"
+			"InnoDB: 200 kB * innodb_thread_concurrency.");
 	}
-
+	margin = smallest_capacity - free;
 	margin = margin - margin / 10;	/* Add still some extra safety */
 
+	mutex_enter(&log_sys->mutex);
+
 	log_sys->log_group_capacity = smallest_capacity;
 
 	log_sys->max_modified_age_async = margin
@@ -927,22 +901,17 @@ log_calc_max_ages(void)
 	log_sys->max_checkpoint_age = margin;
 
 #ifdef UNIV_LOG_ARCHIVE
-	log_sys->max_archived_lsn_age = smallest_archive_margin;
+	lsn_t archive_margin = smallest_capacity
+		- (srv_log_file_size_requested - LOG_FILE_HDR_SIZE)
+		- LOG_ARCHIVE_EXTRA_MARGIN;
+	log_sys->max_archived_lsn_age = archive_margin;
 
-	log_sys->max_archived_lsn_age_async = smallest_archive_margin
-		- smallest_archive_margin / LOG_ARCHIVE_RATIO_ASYNC;
+	log_sys->max_archived_lsn_age_async = archive_margin
+		- archive_margin / LOG_ARCHIVE_RATIO_ASYNC;
 #endif /* UNIV_LOG_ARCHIVE */
-failure:
-	mutex_exit(&(log_sys->mutex));
-
-	if (!success) {
-		ib_logf(IB_LOG_LEVEL_FATAL,
-			"The combined size of ib_logfiles"
-			" should be bigger than\n"
-			"InnoDB: 200 kB * innodb_thread_concurrency.");
-	}
+	mutex_exit(&log_sys->mutex);
 
-	return(success);
+	return(true);
 }
 
 /******************************************************//**